diff --git a/.github/actions/log-cpu/action.yml b/.github/actions/log-cpu/action.yml
index 69ae6dc05..b47cea486 100644
--- a/.github/actions/log-cpu/action.yml
+++ b/.github/actions/log-cpu/action.yml
@@ -30,6 +30,32 @@ inputs:
 runs:
   using: composite
   steps:
+    # PR benchmarks execute trusted workflow YAML from the default branch but
+    # load this action from the PR checkout. Ensure a freshly checked-out base
+    # has its pinned Rust toolchain before Lake invokes Cargo.
+    - name: Bootstrap base Rust toolchain
+      if: inputs.label == 'Base benchmark binary build CPU'
+      shell: bash
+      run: |
+        set -euo pipefail
+
+        toolchain_file=base/rust-toolchain.toml
+        [ -f "$toolchain_file" ] || { echo "::error::$toolchain_file is missing"; exit 1; }
+        channel=$(awk -F '"' '/^[[:space:]]*channel[[:space:]]*=/ { print $2; exit }' "$toolchain_file")
+        profile=$(awk -F '"' '/^[[:space:]]*profile[[:space:]]*=/ { print $2; exit }' "$toolchain_file")
+        if [[ ! "$channel" =~ ^[A-Za-z0-9._+-]+$ ]]; then
+          echo "::error::$toolchain_file has an invalid Rust channel"
+          exit 1
+        fi
+        case "${profile:-default}" in
+          minimal|default|complete) ;;
+          *) echo "::error::$toolchain_file has an invalid Rust profile"; exit 1 ;;
+        esac
+
+        rustup run "$channel" rustc --version >/dev/null 2>&1 && exit 0
+        echo "Installing Rust $channel (${profile:-default} profile) for the fresh base build"
+        rustup toolchain install "$channel" --profile "${profile:-default}" --no-self-update
+
     - shell: bash
       env:
         CPU_LABEL: ${{ inputs.label }}
diff --git a/.github/actions/setup-rust-toolchain/action.yml b/.github/actions/setup-rust-toolchain/action.yml
index 420414345..6692caa65 100644
--- a/.github/actions/setup-rust-toolchain/action.yml
+++ b/.github/actions/setup-rust-toolchain/action.yml
@@ -7,8 +7,8 @@ inputs:
   cache-workspaces:
     description: Cargo workspaces to cache
     required: false
-  native-codegen:
-    description: Enable code generation for the runner's native CPU
+  avx512-codegen:
+    description: Enable AVX-512 code generation for the Warp x64 fleet's common ISA
     required: false
     default: "true"
 
@@ -40,10 +40,33 @@ runs:
           echo "CARGO_NET_GIT_FETCH_WITH_CLI=true" >> "$GITHUB_ENV"
         fi
 
+    # The fleet mixes Intel Granite Rapids and AMD Zen 5, and a binary may be
+    # built on one and measured on another. Neither vendor's feature set
+    # contains the other's, so `-Ctarget-cpu=native` is not portable across
+    # the fleet: Zen 5 enables SSE4A, which LLVM emits (as INSERTQ, in
+    # witness generation) and Intel traps on with #UD. Pin the measured
+    # intersection instead. x86-64-v4 covers every AVX-512 subset Plonky3
+    # uses; +avx512vbmi2 keeps its VPSHRDQ interleave and +gfni keeps LLVM's
+    # byte-shift lowering. blake3 selects its kernels via CPUID at runtime
+    # and is unaffected. Pinning also makes codegen host-independent, so the
+    # cache key below is sound and main-vs-PR timings stay comparable.
+    - name: Require the fleet's baseline CPU features
+      if: inputs.avx512-codegen == 'true'
+      shell: bash
+      run: |
+        missing=()
+        for f in avx512f avx512bw avx512cd avx512dq avx512vl avx512_vbmi2 gfni; do
+          grep -qw "$f" /proc/cpuinfo || missing+=("$f")
+        done
+        if [ ${#missing[@]} -gt 0 ]; then
+          echo "::error::Runner CPU lacks required feature(s): ${missing[*]}. Benchmark binaries are built for x86-64-v4 +avx512vbmi2,+gfni."
+          exit 1
+        fi
+
     - uses: actions-rust-lang/setup-rust-toolchain@v1
       with:
-        rustflags: ${{ inputs.native-codegen == 'true' && '-Ctarget-cpu=native -Dwarnings' || '-Dwarnings' }}
-        # `target/` may contain host-executed native code. Every caller runs
-        # within the Warp x64 compatibility domain.
+        rustflags: ${{ inputs.avx512-codegen == 'true' && '-Ctarget-cpu=x86-64-v4 -Ctarget-feature=+avx512vbmi2,+gfni -Dwarnings' || '-Dwarnings' }}
+        # Codegen is pinned above, so `target/` artifacts are interchangeable
+        # across every Warp x64 host.
         cache-key: warp-x64
         cache-workspaces: ${{ inputs.cache-workspaces }}
diff --git a/.github/workflows/merge-tests.yml b/.github/workflows/merge-tests.yml
index 161dacae2..dccdf83cd 100644
--- a/.github/workflows/merge-tests.yml
+++ b/.github/workflows/merge-tests.yml
@@ -68,8 +68,8 @@ jobs:
       - uses: actions/checkout@v7
       - uses: ./.github/actions/setup-rust-toolchain
         with:
-          # Valgrind cannot decode AVX-512 emitted by native codegen.
-          native-codegen: ${{ matrix.kind != 'valgrind' }}
+          # Valgrind cannot decode the AVX-512 the fleet baseline emits.
+          avx512-codegen: ${{ matrix.kind != 'valgrind' }}
 
       # A merge group has its own SHA, so restore the nearest compatible build
       # produced by ordinary CI and let Lake rebuild anything that changed.
diff --git a/Benchmarks/Compile/lake-manifest.json b/Benchmarks/Compile/lake-manifest.json
index 5ffda5058..74b77d83a 100644
--- a/Benchmarks/Compile/lake-manifest.json
+++ b/Benchmarks/Compile/lake-manifest.json
@@ -182,10 +182,10 @@
    "type": "git",
    "subDir": null,
    "scope": "",
-   "rev": "db25a8a21579d8211eec4347402721f5674bf2c1",
+   "rev": "e6e908bfd3af607ab44fb462fa2276a2c81addba",
    "name": "Blake3",
    "manifestFile": "lake-manifest.json",
-   "inputRev": "db25a8a21579d8211eec4347402721f5674bf2c1",
+   "inputRev": "e6e908bfd3af607ab44fb462fa2276a2c81addba",
    "inherited": true,
    "configFile": "lakefile.lean"},
   {"url": "https://github.com/argumentcomputer/LSpec",
diff --git a/Benchmarks/RecursionDebug.lean b/Benchmarks/RecursionDebug.lean
index 41167de24..ec4a059b7 100644
--- a/Benchmarks/RecursionDebug.lean
+++ b/Benchmarks/RecursionDebug.lean
@@ -102,19 +102,21 @@ def proveConst (ixePath constName : String) (skipDeps : Bool)
       match aiurSystem.proveAddrWithEnv funIdx envHandle addr.hash with
       | .error e => IO.eprintln s!"proveAddrWithEnv failed: {e}"; return none
       | .ok (claimBytes, proof, _) =>
-        -- `verify_claim`'s public input is the 32-G blake3 digest of the
-        -- serialized `Ix.Claim` (same recipe as `ix verify` / bench-typecheck).
+        -- `verify_claim` takes the packed Blake3 digest used by the
+        -- production typecheck path: eight field elements of four bytes.
         let digest := Address.blake3 claimBytes
-        pure (Aiur.buildClaim funIdx (digest.hash.data.map .ofUInt8) #[], proof)
+        pure (Aiur.buildClaim funIdx (IxVM.ClaimHarness.packedDigestKey digest) #[], proof)
   let t1 ← IO.monoNanosNow
-  let proofBytes := proof.toBytes
-  IO.println s!"inner prove: {secs t0 t1} s, proof {proofBytes.size} bytes"
+  IO.println s!"inner prove: {secs t0 t1} s, proof {proof.toBytes.size} bytes"
   -- Sanity: the inner proof must verify out-of-circuit before we chase the
   -- recursive verifier.
   match aiurSystem.verify claim proof with
   | .ok () => IO.println "inner proof verifies out-of-circuit: ok"
   | .error e => IO.eprintln s!"⚠ inner proof FAILS out-of-circuit verify: {e}"
-  return some (proofBytes, aiurSystem.vkBytes, MultiStark.serializeClaims #[claim])
+  match aiurSystem.proofToAdviceBytes claim proof with
+  | .error e => IO.eprintln s!"advice re-encoding failed: {e}"; return none
+  | .ok adviceBytes =>
+    return some (adviceBytes, aiurSystem.vkBytes, MultiStark.serializeClaims #[claim])
 
 def main (args : List String) : IO UInt32 := do
   let ixePath := (argStr args "--ixe").getD "init.ixe"
diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean
index 177905eae..359323bcf 100644
--- a/Benchmarks/Typecheck.lean
+++ b/Benchmarks/Typecheck.lean
@@ -592,10 +592,17 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
           let claimBytes := MultiStark.serializeClaims #[claim]
           let vkBytes := aiurSystem.vkBytes
           let pubInput := MultiStark.verifierPubInput vkBytes claimBytes
+          -- Native proof bytes use P3's pruned multiproof format. The
+          -- in-circuit verifier consumes equivalent per-query path advice.
+          let adviceBytes ← match aiurSystem.proofToAdviceBytes claim proof with
+            | .ok bytes => pure bytes
+            | .error e =>
+              IO.eprintln s!"  ❌ advice re-encoding for {r.name} FAILED: {e}"
+              continue
           -- Native path: the advice buffer is built in Rust from the raw
           -- byte blobs and execution routes through the codegen'd verifier.
           let (rvRes, rvSec) ← timed fun _ =>
-            vCompiled.bytecode.executeMultiStark vIdx pubInput proofBytes
+            vCompiled.bytecode.executeMultiStark vIdx pubInput adviceBytes
               vkBytes claimBytes useInterp
           match rvRes with
           | .error e =>
@@ -621,7 +628,7 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
             (← IO.getStdout).flush
             TracingTexray.resetPeakTreeRss
             let (rvProveRes, rvProveSec) ← timed fun _ =>
-              vSystem.proveMultiStark vIdx pubInput proofBytes vkBytes
+              vSystem.proveMultiStark vIdx pubInput adviceBytes vkBytes
                 claimBytes useInterp
             let (rvClaim, rvProof) ← match rvProveRes with
               | .ok result => pure result
diff --git a/Cargo.lock b/Cargo.lock
index db881f753..be0169f6b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -54,7 +54,7 @@ dependencies = [
  "indexmap",
  "libc",
  "multi-stark",
- "num-bigint",
+ "num-bigint 0.4.6",
  "rayon",
  "rustc-hash",
  "tracing",
@@ -192,7 +192,7 @@ name = "bignat"
 version = "0.1.0"
 source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=2a9c91eba44ea791978a086a6a19b3a922edfee5#2a9c91eba44ea791978a086a6a19b3a922edfee5"
 dependencies = [
- "num-bigint",
+ "num-bigint 0.4.6",
 ]
 
 [[package]]
@@ -331,6 +331,17 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
+[[package]]
+name = "chacha20"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "rand_core 0.10.1",
+]
+
 [[package]]
 name = "chrono"
 version = "0.4.44"
@@ -1735,6 +1746,15 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.18"
@@ -1774,7 +1794,7 @@ dependencies = [
  "ix-common",
  "ix-kernel",
  "ixon",
- "num-bigint",
+ "num-bigint 0.4.6",
  "rayon",
  "rustc-hash",
  "sha2 0.10.9",
@@ -1807,7 +1827,7 @@ dependencies = [
  "mimalloc",
  "multi-stark",
  "n0-error",
- "num-bigint",
+ "num-bigint 0.4.6",
  "rayon",
  "rustc-hash",
  "serde",
@@ -1839,7 +1859,7 @@ dependencies = [
  "ix-common",
  "ixon",
  "log",
- "num-bigint",
+ "num-bigint 0.4.6",
  "quickcheck",
  "quickcheck_macros",
  "rayon",
@@ -1857,7 +1877,7 @@ dependencies = [
  "ix-common",
  "memmap2",
  "nom",
- "num-bigint",
+ "num-bigint 0.4.6",
  "quickcheck",
  "quickcheck_macros",
  "rayon",
@@ -1875,7 +1895,7 @@ dependencies = [
  "ix-common",
  "ixon",
  "multi-stark",
- "num-bigint",
+ "num-bigint 0.4.6",
  "rayon",
  "rustc-hash",
  "stacker",
@@ -1907,7 +1927,7 @@ dependencies = [
  "bignat",
  "bindgen",
  "cc",
- "num-bigint",
+ "num-bigint 0.4.6",
 ]
 
 [[package]]
@@ -2084,7 +2104,7 @@ dependencies = [
 [[package]]
 name = "multi-stark"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=e43201522a95775d1495b4467fbab69fbf7a1ae8#e43201522a95775d1495b4467fbab69fbf7a1ae8"
+source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=a8aab731af8d2a5e15f390cd2ef14af4fc42d7d3#a8aab731af8d2a5e15f390cd2ef14af4fc42d7d3"
 dependencies = [
  "bincode",
  "itertools 0.14.0",
@@ -2096,7 +2116,6 @@ dependencies = [
  "p3-field",
  "p3-fri",
  "p3-goldilocks",
- "p3-interpolation",
  "p3-keccak",
  "p3-matrix",
  "p3-maybe-rayon",
@@ -2371,6 +2390,16 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "num-bigint"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93e7820bc0a80a0238e650327316f929ba18d5be054b647490a3a6a339f3e7c0"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-conv"
 version = "0.2.1"
@@ -2506,18 +2535,19 @@ checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
 
 [[package]]
 name = "p3-air"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
  "p3-field",
  "p3-matrix",
+ "serde",
  "tracing",
 ]
 
 [[package]]
 name = "p3-blake3"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
  "blake3",
  "p3-symmetric",
@@ -2526,12 +2556,11 @@ dependencies = [
 
 [[package]]
 name = "p3-challenger"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
  "p3-field",
  "p3-maybe-rayon",
- "p3-monty-31",
  "p3-symmetric",
  "p3-util",
  "tracing",
@@ -2539,40 +2568,39 @@ dependencies = [
 
 [[package]]
 name = "p3-commit"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
- "itertools 0.14.0",
- "p3-challenger",
+ "itertools 0.15.0",
  "p3-dft",
  "p3-field",
- "p3-interpolation",
  "p3-matrix",
+ "p3-multilinear-util",
  "p3-util",
  "serde",
 ]
 
 [[package]]
 name = "p3-dft"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
- "itertools 0.14.0",
+ "itertools 0.15.0",
  "p3-field",
  "p3-matrix",
  "p3-maybe-rayon",
  "p3-util",
- "spin 0.10.1",
+ "spin 0.12.3",
  "tracing",
 ]
 
 [[package]]
 name = "p3-field"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
- "itertools 0.14.0",
- "num-bigint",
+ "itertools 0.15.0",
+ "num-bigint 0.5.1",
  "p3-maybe-rayon",
  "p3-util",
  "paste",
@@ -2583,32 +2611,31 @@ dependencies = [
 
 [[package]]
 name = "p3-fri"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
- "itertools 0.14.0",
+ "itertools 0.15.0",
  "p3-challenger",
  "p3-commit",
  "p3-dft",
  "p3-field",
- "p3-interpolation",
  "p3-matrix",
  "p3-maybe-rayon",
+ "p3-security",
  "p3-util",
  "rand 0.10.1",
  "serde",
- "spin 0.10.1",
+ "spin 0.12.3",
  "thiserror",
  "tracing",
 ]
 
 [[package]]
 name = "p3-goldilocks"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
- "num-bigint",
- "p3-challenger",
+ "num-bigint 0.5.1",
  "p3-dft",
  "p3-field",
  "p3-mds",
@@ -2619,23 +2646,13 @@ dependencies = [
  "paste",
  "rand 0.10.1",
  "serde",
-]
-
-[[package]]
-name = "p3-interpolation"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
-dependencies = [
- "p3-field",
- "p3-matrix",
- "p3-maybe-rayon",
- "p3-util",
+ "spin 0.12.3",
 ]
 
 [[package]]
 name = "p3-keccak"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
  "p3-symmetric",
  "p3-util",
@@ -2644,10 +2661,10 @@ dependencies = [
 
 [[package]]
 name = "p3-matrix"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
- "itertools 0.14.0",
+ "itertools 0.15.0",
  "p3-field",
  "p3-maybe-rayon",
  "p3-util",
@@ -2658,16 +2675,16 @@ dependencies = [
 
 [[package]]
 name = "p3-maybe-rayon"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
  "rayon",
 ]
 
 [[package]]
 name = "p3-mds"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
  "p3-dft",
  "p3-field",
@@ -2678,10 +2695,10 @@ dependencies = [
 
 [[package]]
 name = "p3-merkle-tree"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
- "itertools 0.14.0",
+ "itertools 0.15.0",
  "p3-commit",
  "p3-field",
  "p3-matrix",
@@ -2690,47 +2707,41 @@ dependencies = [
  "p3-util",
  "rand 0.10.1",
  "serde",
+ "spin 0.12.3",
  "thiserror",
  "tracing",
 ]
 
 [[package]]
-name = "p3-monty-31"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+name = "p3-multilinear-util"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
- "itertools 0.14.0",
- "num-bigint",
- "p3-dft",
+ "itertools 0.15.0",
  "p3-field",
  "p3-matrix",
  "p3-maybe-rayon",
- "p3-mds",
- "p3-poseidon1",
- "p3-poseidon2",
- "p3-symmetric",
  "p3-util",
- "paste",
  "rand 0.10.1",
  "serde",
- "spin 0.10.1",
  "tracing",
 ]
 
 [[package]]
 name = "p3-poseidon1"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
  "p3-field",
+ "p3-mds",
  "p3-symmetric",
  "rand 0.10.1",
 ]
 
 [[package]]
 name = "p3-poseidon2"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
  "p3-field",
  "p3-mds",
@@ -2739,12 +2750,24 @@ dependencies = [
  "rand 0.10.1",
 ]
 
+[[package]]
+name = "p3-security"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
+dependencies = [
+ "libm",
+ "p3-air",
+ "p3-field",
+ "p3-util",
+ "serde",
+]
+
 [[package]]
 name = "p3-symmetric"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
- "itertools 0.14.0",
+ "itertools 0.15.0",
  "p3-field",
  "p3-util",
  "serde",
@@ -2752,11 +2775,11 @@ dependencies = [
 
 [[package]]
 name = "p3-util"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c"
 dependencies = [
+ "p3-maybe-rayon",
  "serde",
- "transpose",
 ]
 
 [[package]]
@@ -3158,6 +3181,7 @@ version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207"
 dependencies = [
+ "chacha20",
  "getrandom 0.4.2",
  "rand_core 0.10.1",
 ]
@@ -3614,6 +3638,12 @@ name = "spin"
 version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "023a211cb3138dbc438680b32560ad89f699977624c9f8dbb95a47d5b4c07dd3"
+
+[[package]]
+name = "spin"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0134f9043ed38b087ac4f7d4af44c79e2c9e5094421fe3164f435ce585953b10"
 dependencies = [
  "lock_api",
 ]
@@ -3647,12 +3677,6 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "strength_reduce"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82"
-
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -4064,16 +4088,6 @@ dependencies = [
  "tracing-subscriber",
 ]
 
-[[package]]
-name = "transpose"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ad61aed86bc3faea4300c7aee358b4c6d0c8d6ccc36524c96e4c92ccf26e77e"
-dependencies = [
- "num-integer",
- "strength_reduce",
-]
-
 [[package]]
 name = "try-lock"
 version = "0.2.5"
diff --git a/Cargo.toml b/Cargo.toml
index 1791ae265..273dd4451 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -56,7 +56,7 @@ libc = "0.2"
 log = "0.4"
 memmap2 = "0.9"
 mimalloc = { version = "0.1", default-features = false }
-multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "e43201522a95775d1495b4467fbab69fbf7a1ae8" }
+multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "a8aab731af8d2a5e15f390cd2ef14af4fc42d7d3" }
 nom = "7.1.3"
 num-bigint = "0.4.6"
 quickcheck = "1.0.3"
@@ -98,7 +98,6 @@ filter_map_next = "warn"
 flat_map_option = "warn"
 fn_to_numeric_cast = "warn"
 fn_to_numeric_cast_with_truncation = "warn"
-from_iter_instead_of_collect = "warn"
 implicit_clone = "warn"
 inefficient_to_string = "warn"
 invalid_upcast_comparisons = "warn"
diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean
index 412ad59ea..43ce405ec 100644
--- a/Ix/Aiur/Protocol.lean
+++ b/Ix/Aiur/Protocol.lean
@@ -189,6 +189,12 @@ def shardProveWithEnv (system : @& AiurSystem)
 opaque verify : @& AiurSystem →
   @& Array G → @& Proof → Except String Unit
 
+/-- Re-encode a natively valid proof into the per-query Merkle-path advice
+transport consumed by the in-circuit recursive verifier. -/
+@[extern "rs_aiur_proof_to_advice_bytes"]
+opaque proofToAdviceBytes : @& AiurSystem →
+  @& Array G → @& Proof → Except String ByteArray
+
 end AiurSystem
 
 namespace Bytecode.Toplevel
diff --git a/Ix/IxVM/Core.lean b/Ix/IxVM/Core.lean
index a32e74d71..619ba613e 100644
--- a/Ix/IxVM/Core.lean
+++ b/Ix/IxVM/Core.lean
@@ -18,6 +18,16 @@ def core := ⟦
     None
   }
 
+  -- Memoized u32 comparison for hot structural and frontier walks. Aiur
+  -- memoizes function calls automatically, so keeping the decomposition in
+  -- this shared helper avoids charging the wide intrinsic layout repeatedly;
+  -- recurring `(a, b)` pairs share one constrained helper row. This belongs
+  -- in Core because both the IxVM substitution circuits and the recursive
+  -- multi-STARK verifier rely on the same optimization.
+  fn memo_u32_less_than(a: G, b: G) -> G {
+    u32_less_than(a, b)
+  }
+
   -- Interned 32-element address (blake3 content hash).
   --
   -- DIFFERENT POINTER VALUES DO NOT IMPLY DIFFERENT DATA. The Aiur
diff --git a/Ix/IxVM/Kernel/Subst.lean b/Ix/IxVM/Kernel/Subst.lean
index 5250e5815..1a1b8bef9 100644
--- a/Ix/IxVM/Kernel/Subst.lean
+++ b/Ix/IxVM/Kernel/Subst.lean
@@ -90,14 +90,6 @@ def subst := ⟦
     }
   }
 
-  -- Memoized structural comparison used by substitution fast paths. Keeping
-  -- the u32 decomposition in this helper avoids charging its wide intrinsic
-  -- layout on every row of a hot substitution circuit; repeated `(depth,lbr)`
-  -- pairs share one constrained helper row.
-  fn memo_u32_less_than(a: G, b: G) -> G {
-    u32_less_than(a, b)
-  }
-
   -- ============================================================================
   -- has_bvar_in_range
   --
diff --git a/Ix/MultiStark/Deserialize.lean b/Ix/MultiStark/Deserialize.lean
index 96fcb9cbf..2a808d36d 100644
--- a/Ix/MultiStark/Deserialize.lean
+++ b/Ix/MultiStark/Deserialize.lean
@@ -79,34 +79,37 @@ def deserialize := ⟦
     Mk(MerkleCap, MerkleCap, MerkleCap)
   }
 
-  -- `BatchOpening<Val, Mmcs>`: per-round input opening of a FRI query.
-  --   opened_values : Vec<Vec<Val>>   (one row of base-field values per matrix)
-  --   opening_proof : Vec<Digest>     (Merkle authentication path)
-  enum BatchOpening {
-    Mk(List‹List‹U64››, List‹DigestP›)
+  -- One input commitment opened at all query indices with a shared pruned
+  -- Merkle frontier. `opened_values[q][m]` is query q's row of matrix m.
+  enum BatchMultiOpening {
+    Mk(List‹List‹List‹U64›››, List‹DigestP›)
   }
 
   -- `CommitPhaseProofStep<ExtVal, ExtMmcs>`: one folding step of a FRI query.
   --   log_arity      : u8
   --   sibling_values : Vec<Ext>  (arity - 1 siblings)
   --   opening_proof  : Vec<Digest>
-  enum CommitPhaseProofStep {
-    Mk(U8, List‹Ext›, List‹DigestP›)
+  enum CommitPhaseMultiStep {
+    Mk(U8, List‹List‹Ext››, List‹DigestP›)
   }
 
-  -- `QueryProof<ExtVal, ExtMmcs, Vec<BatchOpening<Val, Mmcs>>>`.
-  enum QueryProof {
-    Mk(List‹BatchOpening›, List‹CommitPhaseProofStep›)
-  }
+  -- Per-query views derived in-circuit from the native batch openings. They
+  -- retain the existing FRI arithmetic organization; authentication is done
+  -- once per native multiproof before that arithmetic runs.
+  enum BatchOpening { Mk(List‹List‹U64››) }
+  enum CommitPhaseProofStep { Mk(U8, List‹Ext›) }
+  enum QueryProof { Mk(List‹BatchOpening›, List‹CommitPhaseProofStep›) }
 
   -- `PcsProof = FriProof<ExtVal, ExtMmcs, Witness = Val, ..>`.
   --   commit_phase_commits : Vec<MerkleCap>
   --   commit_pow_witnesses : Vec<Val>
-  --   query_proofs         : Vec<QueryProof>
+  --   input_openings       : Vec<BatchMultiOpening>
+  --   commit_phase_openings: Vec<CommitPhaseMultiStep>
   --   final_poly           : Vec<Ext>
   --   query_pow_witness    : Val
   enum FriProof {
-    Mk(List‹MerkleCap›, List‹U64›, List‹QueryProof›, List‹Ext›, U64)
+    Mk(List‹MerkleCap›, List‹U64›, List‹BatchMultiOpening›,
+       List‹CommitPhaseMultiStep›, List‹Ext›, U64)
   }
 
   -- `Option<OpenedRound>` for `preprocessed_opened_values`. A dedicated
@@ -301,6 +304,20 @@ def deserialize := ⟦
     }
   }
 
+  fn read_u64_vec_vec_vec(i: G) -> (List‹List‹List‹U64›››, G) {
+    let (n, j) = read_count_at(i);
+    read_u64_vec_vec_vec_n(j, n)
+  }
+  fn read_u64_vec_vec_vec_n(i: G, n: G) -> (List‹List‹List‹U64›››, G) {
+    match n {
+      0 => (store(ListNode.Nil), i),
+      _ =>
+        let (x, j) = @read_u64_vec_vec(i);
+        let (rest, j2) = read_u64_vec_vec_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
+    }
+  }
+
   -- `OpenedRound = Vec<Vec<Vec<Ext>>>`, built bottom-up from `read_ext_vec`.
   fn read_ext_vec_vec(i: G) -> (List‹List‹Ext››, G) {
     let (n, j) = read_count_at(i);
@@ -358,16 +375,16 @@ def deserialize := ⟦
     (Commitments.Mk(stage_1_trace, stage_2_trace, quotient_chunks), j2)
   }
 
-  fn read_batch_opening(i: G) -> (BatchOpening, G) {
-    let (opened_values, j0) = @read_u64_vec_vec(i);
+  fn read_batch_opening(i: G) -> (BatchMultiOpening, G) {
+    let (opened_values, j0) = @read_u64_vec_vec_vec(i);
     let (opening_proof, j1) = read_digest_vec_at(j0);
-    (BatchOpening.Mk(opened_values, opening_proof), j1)
+    (BatchMultiOpening.Mk(opened_values, opening_proof), j1)
   }
-  fn read_batch_opening_vec(i: G) -> (List‹BatchOpening›, G) {
+  fn read_batch_opening_vec(i: G) -> (List‹BatchMultiOpening›, G) {
     let (n, j) = read_count_at(i);
     read_batch_opening_vec_n(j, n)
   }
-  fn read_batch_opening_vec_n(i: G, n: G) -> (List‹BatchOpening›, G) {
+  fn read_batch_opening_vec_n(i: G, n: G) -> (List‹BatchMultiOpening›, G) {
     match n {
       0 => (store(ListNode.Nil), i),
       _ =>
@@ -377,17 +394,17 @@ def deserialize := ⟦
     }
   }
 
-  fn read_commit_phase_step(i: G) -> (CommitPhaseProofStep, G) {
+  fn read_commit_phase_step(i: G) -> (CommitPhaseMultiStep, G) {
     let (log_arity, j0) = #read_u8_at(i);
-    let (sibling_values, j1) = read_ext_vec(j0);
+    let (sibling_values, j1) = @read_ext_vec_vec(j0);
     let (opening_proof, j2) = read_digest_vec_at(j1);
-    (CommitPhaseProofStep.Mk(log_arity, sibling_values, opening_proof), j2)
+    (CommitPhaseMultiStep.Mk(log_arity, sibling_values, opening_proof), j2)
   }
-  fn read_commit_phase_step_vec(i: G) -> (List‹CommitPhaseProofStep›, G) {
+  fn read_commit_phase_step_vec(i: G) -> (List‹CommitPhaseMultiStep›, G) {
     let (n, j) = read_count_at(i);
     read_commit_phase_step_vec_n(j, n)
   }
-  fn read_commit_phase_step_vec_n(i: G, n: G) -> (List‹CommitPhaseProofStep›, G) {
+  fn read_commit_phase_step_vec_n(i: G, n: G) -> (List‹CommitPhaseMultiStep›, G) {
     match n {
       0 => (store(ListNode.Nil), i),
       _ =>
@@ -397,33 +414,15 @@ def deserialize := ⟦
     }
   }
 
-  fn read_query_proof(i: G) -> (QueryProof, G) {
-    let (input_proof, j0) = @read_batch_opening_vec(i);
-    let (commit_phase_openings, j1) = @read_commit_phase_step_vec(j0);
-    (QueryProof.Mk(input_proof, commit_phase_openings), j1)
-  }
-  fn read_query_proof_vec(i: G) -> (List‹QueryProof›, G) {
-    let (n, j) = read_count_at(i);
-    read_query_proof_vec_n(j, n)
-  }
-  fn read_query_proof_vec_n(i: G, n: G) -> (List‹QueryProof›, G) {
-    match n {
-      0 => (store(ListNode.Nil), i),
-      _ =>
-        let (x, j) = @read_query_proof(i);
-        let (rest, j2) = read_query_proof_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
-    }
-  }
-
   fn read_fri_proof(i: G) -> (FriProof, G) {
     let (commit_phase_commits, j0) = @read_merkle_cap_vec(i);
     let (commit_pow_witnesses, j1) = read_u64_vec(j0);
-    let (query_proofs, j2) = @read_query_proof_vec(j1);
-    let (final_poly, j3) = read_ext_vec(j2);
-    let (query_pow_witness, j4) = #read_u64_at(j3);
-    (FriProof.Mk(commit_phase_commits, commit_pow_witnesses, query_proofs,
-                 final_poly, query_pow_witness), j4)
+    let (input_openings, j2) = @read_batch_opening_vec(j1);
+    let (commit_phase_openings, j3) = @read_commit_phase_step_vec(j2);
+    let (final_poly, j4) = read_ext_vec(j3);
+    let (query_pow_witness, j5) = #read_u64_at(j4);
+    (FriProof.Mk(commit_phase_commits, commit_pow_witnesses, input_openings,
+                 commit_phase_openings, final_poly, query_pow_witness), j5)
   }
 
   -- The activation bitmap: `Vec<bool>` on the wire (u64 count, then one
diff --git a/Ix/MultiStark/Pcs.lean b/Ix/MultiStark/Pcs.lean
index 82a147c20..0947e1d27 100644
--- a/Ix/MultiStark/Pcs.lean
+++ b/Ix/MultiStark/Pcs.lean
@@ -389,6 +389,27 @@ def pcs := ⟦
     }
   }
 
+  -- Rows of matrices at log-height <= `target`, in circuit order. Used to
+  -- cross-check that two frontier queries sharing a parent agree on every
+  -- not-yet-injected (shorter) matrix: only the group lead's rows are hashed
+  -- into the shared frontier, so the others must be pinned to match it
+  -- (Plonky3 `verify_batch_pruned`'s `InconsistentGroupOpening`). Skips
+  -- empty (inactive-circuit) rows exactly as `select_rows`.
+  fn select_rows_le(rows: List‹List‹U64››, lhs: List‹G›, target: G) -> List‹List‹U64›› {
+    match load(rows) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(r, rrest) =>
+        let &ListNode.Cons(lh, lrest) = lhs;
+        match u32_less_than(target, lh) {
+          1 => select_rows_le(rrest, lrest, target),
+          _ => match load(r) {
+            ListNode.Nil => select_rows_le(rrest, lrest, target),
+            _ => store(ListNode.Cons(r, select_rows_le(rrest, lrest, target))),
+          },
+        },
+    }
+  }
+
   -- Pop one canonicalized lane across row boundaries. `got = 0` iff both the
   -- current row and the remaining rows are exhausted (selected rows are
   -- non-empty, so advancing to the next row always yields a lane).
@@ -515,6 +536,144 @@ def pcs := ⟦
     eq_zero(ptr_val(list_lookup(cap, capidx)) - ptr_val(root))
   }
 
+  -- A node in the sorted multiproof frontier. Rows are retained from the
+  -- lead query so shorter matrices can be injected at their native height.
+  enum FrontierNode { Mk(G, List‹G›, List‹List‹U64››, DigestP) }
+
+  fn frontier_merge(xs: List‹FrontierNode›, ys: List‹FrontierNode›) -> List‹FrontierNode› {
+    match load(xs) {
+      ListNode.Nil => ys,
+      ListNode.Cons(x, xrest) => match load(ys) {
+        ListNode.Nil => xs,
+        ListNode.Cons(y, yrest) =>
+          let FrontierNode.Mk(xi, _xb, xr, xd) = x;
+          let FrontierNode.Mk(yi, _yb, yr, yd) = y;
+          match memo_u32_less_than(xi, yi) {
+            1 => store(ListNode.Cons(x, frontier_merge(xrest, ys))),
+            _ => match eq_zero(xi - yi) {
+              1 =>
+                -- Duplicate transcript queries (same index) must open the
+                -- SAME full opened rows, not merely the same tallest-matrix
+                -- leaf digest: their shorter-matrix rows share a reduced index
+                -- too and both feed the FRI arithmetic (Plonky3
+                -- `verify_batch_pruned`'s `InconsistentDuplicateOpenings`).
+                -- Pointer equality is admissible inside `assert_eq!`.
+                assert_eq!(ptr_val(xd), ptr_val(yd));
+                assert_eq!(ptr_val(xr), ptr_val(yr));
+                store(ListNode.Cons(x, frontier_merge(xrest, yrest))),
+              _ => store(ListNode.Cons(y, frontier_merge(xs, yrest))),
+            },
+          },
+      },
+    }
+  }
+
+  -- Deal alternating elements into two half-sized lists. Their internal order
+  -- is irrelevant because each half is recursively sorted before merging.
+  fn frontier_split(xs: List‹FrontierNode›) -> (List‹FrontierNode›, List‹FrontierNode›) {
+    match load(xs) {
+      ListNode.Nil => (store(ListNode.Nil), store(ListNode.Nil)),
+      ListNode.Cons(x, rest) => match load(rest) {
+        ListNode.Nil => (store(ListNode.Cons(x, store(ListNode.Nil))), store(ListNode.Nil)),
+        ListNode.Cons(y, tail) =>
+          let (left, right) = frontier_split(tail);
+          (store(ListNode.Cons(x, left)), store(ListNode.Cons(y, right))),
+      },
+    }
+  }
+
+  fn frontier_sort(xs: List‹FrontierNode›) -> List‹FrontierNode› {
+    match load(xs) {
+      ListNode.Nil => xs,
+      ListNode.Cons(_x, rest) => match load(rest) {
+        ListNode.Nil => xs,
+        ListNode.Cons(_y, _tail) =>
+          let (left, right) = frontier_split(xs);
+          frontier_merge(frontier_sort(left), frontier_sort(right)),
+      },
+    }
+  }
+
+  fn frontier_leaves(indices: List‹List‹G››, rows: List‹List‹List‹U64›››,
+      lhs: List‹G›, log_max: G) -> List‹FrontierNode› {
+    match load(indices) {
+      ListNode.Nil =>
+        assert_eq!(list_length(rows), 0);
+        store(ListNode.Nil),
+      ListNode.Cons(bits, irest) =>
+        let &ListNode.Cons(r, rrest) = rows;
+        let d = leaf_hash_at(r, lhs, log_max);
+        store(ListNode.Cons(FrontierNode.Mk(bits_to_num(bits), bits, r, d),
+          frontier_leaves(irest, rrest, lhs, log_max))),
+    }
+  }
+
+  -- Fold one binary frontier level. Boundary siblings are consumed in the
+  -- exact ascending-parent/ascending-child order used by Plonky3 pruning.
+  fn frontier_level(nodes: List‹FrontierNode›, proof: List‹DigestP›,
+      lhs: List‹G›, next_lh: G) -> (List‹FrontierNode›, List‹DigestP›) {
+    match load(nodes) {
+      ListNode.Nil => (store(ListNode.Nil), proof),
+      ListNode.Cons(a, rest) =>
+        let FrontierNode.Mk(ai, abits, ar, ad) = a;
+        let &ListNode.Cons(abit, aparent_bits) = abits;
+        let aparent = bits_to_num(aparent_bits);
+        match load(rest) {
+          ListNode.Cons(b, brest) =>
+            let FrontierNode.Mk(bi, bbits, br, bd) = b;
+            let &ListNode.Cons(_bbit, bparent_bits) = bbits;
+            match eq_zero(aparent - bits_to_num(bparent_bits)) {
+              1 =>
+                -- Group members sharing a parent are collapsed to the lead
+                -- `a`; only `ar` is injected from here up, so `b` must agree
+                -- with `a` on every not-yet-injected (height <= next_lh)
+                -- matrix. Otherwise `b`'s shorter-matrix opened rows, still
+                -- consumed in its own FRI arithmetic, would go unauthenticated
+                -- (Plonky3 `verify_batch_pruned`'s `InconsistentGroupOpening`;
+                -- pointer equality is admissible inside `assert_eq!` — see
+                -- `IxVM.Core`). Transitive across pairwise merges, so the whole
+                -- group is pinned.
+                assert_eq!(ptr_val(select_rows_le(ar, lhs, next_lh)),
+                           ptr_val(select_rows_le(br, lhs, next_lh)));
+                let parent = inject_maybe(ar, lhs, next_lh, mmcs_compress(ad, bd));
+                let (tail, p2) = frontier_level(brest, proof, lhs, next_lh);
+                (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), tail)), p2),
+              _ =>
+                let &ListNode.Cons(sib, prest) = proof;
+                let parent = inject_maybe(ar, lhs, next_lh, compress_ordered(abit, ad, sib));
+                let (tail, p2) = frontier_level(rest, prest, lhs, next_lh);
+                (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), tail)), p2),
+            },
+          ListNode.Nil =>
+            let &ListNode.Cons(sib, prest) = proof;
+            let parent = inject_maybe(ar, lhs, next_lh, compress_ordered(abit, ad, sib));
+            (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), store(ListNode.Nil))), prest),
+        },
+    }
+  }
+
+  fn frontier_fold(nodes: List‹FrontierNode›, proof: List‹DigestP›,
+      lhs: List‹G›, levels: G) -> (List‹FrontierNode›, List‹DigestP›) {
+    match levels {
+      0 => (nodes, proof),
+      _ =>
+        let (next, p2) = frontier_level(nodes, proof, lhs, levels - 1);
+        frontier_fold(next, p2, lhs, levels - 1),
+    }
+  }
+
+  fn mmcs_verify_multi(cap: MerkleCap, rows: List‹List‹List‹U64›››,
+      lhs: List‹G›, indices: List‹List‹G››, proof: List‹DigestP›, log_max: G) -> G {
+    assert_eq!(eq_zero(list_length(rows) - list_length(indices)), 1);
+    let leaves = frontier_sort(frontier_leaves(indices, rows, lhs, log_max));
+    let (roots, rest) = frontier_fold(leaves, proof, lhs, log_max);
+    assert_eq!(list_length(rest), 0);
+    let &ListNode.Cons(root, no_more) = roots;
+    assert_eq!(list_length(no_more), 0);
+    let FrontierNode.Mk(capidx, _bits, _rows, digest) = root;
+    eq_zero(ptr_val(list_lookup(cap, capidx)) - ptr_val(digest))
+  }
+
   -- ==========================================================================
   -- FRI fold step (`TwoAdicFriFolding::fold_row`, arity-2 case).
   --
@@ -826,7 +985,7 @@ def pcs := ⟦
     match prep_opt {
       PreprocessedOpt.NoPreprocessed => buckets,
       PreprocessedOpt.SomePreprocessed(prep_round) =>
-        let BatchOpening.Mk(rows_p, proof_p) = list_lookup(input_proof, 3);
+        let BatchOpening.Mk(rows_p) = list_lookup(input_proof, 3);
         -- one opened base row per preprocessed matrix (BatchOpenedValuesCountMismatch)
         assert_eq!(eq_zero(list_length(rows_p) - list_length(prep_round)), 1);
         -- The preprocessed tree's max height is over the PREP circuits only, so
@@ -836,8 +995,6 @@ def pcs := ⟦
         -- of the LSB-first bit list) and verify against the batch's own height.
         let prep_heights = heights_prep(log_degrees, log_blowup, prep_indices, num_circuits, 0);
         let log_pmax = heights_max(prep_heights);
-        assert_eq!(mmcs_verify(prep_commit, rows_p, prep_heights,
-          list_drop(idxbits, log_gmax - log_pmax), proof_p, log_pmax), 1);
         open_prep(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, 0, log_degrees,
                   prep_indices, zeta, rows_p, prep_round, alpha),
     }
@@ -904,7 +1061,7 @@ def pcs := ⟦
   }
   fn verify_query(folded: Ext, betas: List‹Ext›, comms: List‹MerkleCap›,
       openings: List‹CommitPhaseProofStep›, domidx: List‹G›, log_cur: G,
-      ro_rest: List‹Bucket›, log_final: G) -> Ext {
+      ro_rest: List‹Bucket›, log_final: G) -> (Ext, List‹List‹U64››) {
     match load(openings) {
       ListNode.Nil =>
         -- must have folded down to exactly the final domain size, and every
@@ -912,22 +1069,20 @@ def pcs := ⟦
         -- UnconsumedReducedOpenings).
         assert_eq!(eq_zero(log_cur - log_final), 1);
         assert_eq!(list_length(ro_rest), 0);
-        folded,
+        (folded, store(ListNode.Nil)),
       ListNode.Cons(op, op_rest) =>
         let &ListNode.Cons(beta, beta_rest) = betas;
         let &ListNode.Cons(comm, comm_rest) = comms;
-        let CommitPhaseProofStep.Mk(_la, sibs, oproof) = op;
+        let CommitPhaseProofStep.Mk(_la, sibs) = op;
         -- arity 2 ⇒ exactly arity-1 = 1 sibling (SiblingValuesLengthMismatch).
         assert_eq!(list_length(sibs), 1);
         let &ListNode.Cons(ibit, idrest) = domidx;     -- index_in_group = LSB
         let log_folded = log_cur - 1;
         let (e0, e1) = @recon_evals(ibit, folded, list_lookup(sibs, 0));
-        -- authenticate the sibling pair against this round's commitment
-        assert_eq!(mmcs_verify(comm, store(ListNode.Cons(@flatten2(e0, e1), store(ListNode.Nil))),
-          store(ListNode.Cons(log_folded, store(ListNode.Nil))), idrest, oproof, log_folded), 1);
         let folded1 = fri_fold2(idrest, log_folded, beta, e0, e1);
         let (folded2, ro_rest2) = rollin(folded1, log_folded, beta, ro_rest);
-        verify_query(folded2, beta_rest, comm_rest, op_rest, idrest, log_folded, ro_rest2, log_final),
+        let (result, rows) = verify_query(folded2, beta_rest, comm_rest, op_rest, idrest, log_folded, ro_rest2, log_final);
+        (result, store(ListNode.Cons(@flatten2(e0, e1), rows))),
     }
   }
 
@@ -941,7 +1096,7 @@ def pcs := ⟦
       prep_commit: MerkleCap, prep_indices: List‹OptIdx›,
       log_degrees: List‹U8›, zeta: Ext, num_circuits: G, log_blowup: G, log_gmax: G,
       betas: List‹Ext›, commit_phase_commits: List‹MerkleCap›, final_poly: List‹Ext›,
-      num_rounds: G) -> G {
+      num_rounds: G) -> List‹List‹U64›› {
     let QueryProof.Mk(input_proof, commit_phase_openings) = qp;
     -- one commit-phase opening per round (QueryCommitPhaseOpeningsCountMismatch),
     -- one input batch per commitment (InputProofBatchCountMismatch).
@@ -951,19 +1106,16 @@ def pcs := ⟦
     -- one heights list for all three stage batches (memoized anyway; this
     -- also drops two call-output columns per proof)
     let hall = heights_all(log_degrees, log_blowup, num_circuits, 0);
-    let BatchOpening.Mk(rows_s1, proof_s1) = list_lookup(input_proof, 0);
+    let BatchOpening.Mk(rows_s1) = list_lookup(input_proof, 0);
     assert_eq!(eq_zero(list_length(rows_s1) - num_circuits), 1);
-    assert_eq!(mmcs_verify(s1c, rows_s1, hall, idxbits, proof_s1, log_gmax), 1);
     let buckets = open_batch_2pt(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_s1, stage1, alpha);
-    let BatchOpening.Mk(rows_s2, proof_s2) = list_lookup(input_proof, 1);
+    let BatchOpening.Mk(rows_s2) = list_lookup(input_proof, 1);
     assert_eq!(eq_zero(list_length(rows_s2) - num_circuits), 1);
-    assert_eq!(mmcs_verify(s2c, rows_s2, hall, idxbits, proof_s2, log_gmax), 1);
     let buckets = open_batch_2pt(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_s2, stage2, alpha);
-    let BatchOpening.Mk(rows_q, proof_q) = list_lookup(input_proof, 2);
+    let BatchOpening.Mk(rows_q) = list_lookup(input_proof, 2);
     -- one wide quotient matrix per circuit, on the trace domain, so the
     -- quotient batch's heights are the same per-circuit heights as the stages
     assert_eq!(eq_zero(list_length(rows_q) - num_circuits), 1);
-    assert_eq!(mmcs_verify(qc, rows_q, hall, idxbits, proof_q, log_gmax), 1);
     let buckets = open_quotient(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_q, q_opened, alpha);
     let buckets = open_prep_batch(buckets, input_proof, prep_commit, prep_opt, prep_indices, log_degrees, num_circuits, idxbits, log_gmax, log_blowup, zeta, alpha);
     -- a height-`log_blowup` (constant-poly) reduced opening must be zero
@@ -973,10 +1125,10 @@ def pcs := ⟦
     let &ListNode.Cons(b0, ro_rest) = buckets;
     let Bucket.Mk(h0, _ap0, folded_start) = b0;
     assert_eq!(eq_zero(h0 - log_gmax), 1);
-    let folded = verify_query(folded_start, betas, commit_phase_commits, commit_phase_openings, idxbits, log_gmax, ro_rest, log_blowup);
+    let (folded, fri_rows) = verify_query(folded_start, betas, commit_phase_commits, commit_phase_openings, idxbits, log_gmax, ro_rest, log_blowup);
     -- final check: with log_final_poly_len = 0, eval = final_poly[0]
     assert_eq!(@eg_eq(list_lookup(final_poly, 0), folded), 1);
-    1
+    fri_rows
   }
 
   -- Loop over all `num_queries` query proofs, sampling one index per query
@@ -987,17 +1139,106 @@ def pcs := ⟦
       prep_commit: MerkleCap, prep_indices: List‹OptIdx›,
       log_degrees: List‹U8›, zeta: Ext, num_circuits: G, log_blowup: G, log_gmax: G,
       betas: List‹Ext›, commit_phase_commits: List‹MerkleCap›, final_poly: List‹Ext›,
-      num_rounds: G) -> G {
+      num_rounds: G) -> List‹List‹List‹U64››› {
     match load(query_proofs) {
-      ListNode.Nil => 1,
+      ListNode.Nil => store(ListNode.Nil),
       ListNode.Cons(qp, rest) =>
         let (idxbits, input2, output2) = ch_sample_bits(input, output, log_gmax);
-        let _q = verify_one_query(idxbits, qp, alpha, stage1, stage2, q_opened, prep_opt,
+        let qrows = verify_one_query(idxbits, qp, alpha, stage1, stage2, q_opened, prep_opt,
           s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, num_circuits,
           log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds);
-        query_loop(input2, output2, rest, alpha, stage1, stage2, q_opened, prep_opt,
+        store(ListNode.Cons(qrows, query_loop(input2, output2, rest, alpha, stage1, stage2, q_opened, prep_opt,
           s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, num_circuits,
-          log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds),
+          log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds))),
+    }
+  }
+
+  fn sample_query_indices(input: ByteStream, output: ByteStream, n: G,
+      log_gmax: G) -> List‹List‹G›› {
+    match n {
+      0 => store(ListNode.Nil),
+      _ =>
+        let (bits, input2, output2) = ch_sample_bits(input, output, log_gmax);
+        store(ListNode.Cons(bits, sample_query_indices(input2, output2, n - 1, log_gmax))),
+    }
+  }
+
+  fn batch_views_at(bs: List‹BatchMultiOpening›, q: G) -> List‹BatchOpening› {
+    match load(bs) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(b, rest) =>
+        let BatchMultiOpening.Mk(rows, _proof) = b;
+        store(ListNode.Cons(BatchOpening.Mk(list_lookup(rows, q)), batch_views_at(rest, q))),
+    }
+  }
+  fn step_views_at(ss: List‹CommitPhaseMultiStep›, q: G) -> List‹CommitPhaseProofStep› {
+    match load(ss) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(s, rest) =>
+        let CommitPhaseMultiStep.Mk(la, sibs, _proof) = s;
+        store(ListNode.Cons(CommitPhaseProofStep.Mk(la, list_lookup(sibs, q)), step_views_at(rest, q))),
+    }
+  }
+  fn query_views(bs: List‹BatchMultiOpening›, ss: List‹CommitPhaseMultiStep›,
+      q: G, n: G) -> List‹QueryProof› {
+    match n {
+      0 => store(ListNode.Nil),
+      _ => store(ListNode.Cons(QueryProof.Mk(batch_views_at(bs, q), step_views_at(ss, q)),
+             query_views(bs, ss, q + 1, n - 1))),
+    }
+  }
+
+  fn verify_input_multi(bs: List‹BatchMultiOpening›, indices: List‹List‹G››,
+      s1c: MerkleCap, s2c: MerkleCap, qc: MerkleCap, prep_commit: MerkleCap,
+      prep_opt: PreprocessedOpt, prep_indices: List‹OptIdx›, log_degrees: List‹U8›,
+      num_circuits: G, log_blowup: G, log_gmax: G) -> G {
+    let hall = heights_all(log_degrees, log_blowup, num_circuits, 0);
+    let BatchMultiOpening.Mk(s1rows, s1proof) = list_lookup(bs, 0);
+    let BatchMultiOpening.Mk(s2rows, s2proof) = list_lookup(bs, 1);
+    let BatchMultiOpening.Mk(qrows, qproof) = list_lookup(bs, 2);
+    assert_eq!(mmcs_verify_multi(s1c, s1rows, hall, indices, s1proof, log_gmax), 1);
+    assert_eq!(mmcs_verify_multi(s2c, s2rows, hall, indices, s2proof, log_gmax), 1);
+    assert_eq!(mmcs_verify_multi(qc, qrows, hall, indices, qproof, log_gmax), 1);
+    match prep_opt {
+      PreprocessedOpt.NoPreprocessed => 1,
+      PreprocessedOpt.SomePreprocessed(_round) =>
+        let BatchMultiOpening.Mk(prows, pproof) = list_lookup(bs, 3);
+        let ph = heights_prep(log_degrees, log_blowup, prep_indices, num_circuits, 0);
+        let lp = heights_max(ph);
+        let pindices = drop_index_bits(indices, log_gmax - lp);
+        mmcs_verify_multi(prep_commit, prows, ph, pindices, pproof, lp),
+    }
+  }
+  fn drop_index_bits(indices: List‹List‹G››, n: G) -> List‹List‹G›› {
+    match load(indices) {
+      ListNode.Nil => indices,
+      ListNode.Cons(bits, rest) =>
+        store(ListNode.Cons(list_drop(bits, n), drop_index_bits(rest, n))),
+    }
+  }
+  fn rows_at_round(rows: List‹List‹List‹U64›››, r: G) -> List‹List‹List‹U64››› {
+    match load(rows) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(qrows, rest) =>
+        store(ListNode.Cons(store(ListNode.Cons(list_lookup(qrows, r), store(ListNode.Nil))),
+          rows_at_round(rest, r))),
+    }
+  }
+  fn verify_commit_multi(steps: List‹CommitPhaseMultiStep›, comms: List‹MerkleCap›,
+      all_rows: List‹List‹List‹U64›››, indices: List‹List‹G››, r: G,
+      log_cur: G) -> G {
+    match load(steps) {
+      ListNode.Nil => eq_zero(list_length(comms)),
+      ListNode.Cons(s, srest) =>
+        let &ListNode.Cons(c, crest) = comms;
+        let CommitPhaseMultiStep.Mk(la, sibs, proof) = s;
+        assert_eq!(to_field(la), 1);
+        assert_eq!(list_length(sibs), list_length(indices));
+        let next_indices = drop_index_bits(indices, 1);
+        let lh = log_cur - 1;
+        assert_eq!(mmcs_verify_multi(c, rows_at_round(all_rows, r),
+          store(ListNode.Cons(lh, store(ListNode.Nil))), next_indices, proof, lh), 1);
+        verify_commit_multi(srest, crest, all_rows, next_indices, r + 1, lh),
     }
   }
 
@@ -1010,12 +1251,14 @@ def pcs := ⟦
       prep_indices: List‹OptIdx›, log_degrees: List‹U8›,
       zeta: Ext, num_circuits: G, log_blowup: G, num_queries: G, commit_pow_bits: G,
       query_pow_bits: G) -> G {
-    let FriProof.Mk(commit_phase_commits, pw, query_proofs, final_poly, qpw) = opening;
+    let FriProof.Mk(commit_phase_commits, pw, input_openings, commit_phase_openings,
+      final_poly, qpw) = opening;
     let num_rounds = list_length(commit_phase_commits);
     -- FRI shape: one PoW witness per round, num_queries query proofs, and (since
     -- log_final_poly_len = 0) a single final-poly coefficient.
     assert_eq!(eq_zero(list_length(pw) - num_rounds), 1);
-    assert_eq!(eq_zero(list_length(query_proofs) - num_queries), 1);
+    assert_eq!(list_length(input_openings), 3 + prep_count(prep_opt));
+    assert_eq!(eq_zero(list_length(commit_phase_openings) - num_rounds), 1);
     assert_eq!(list_length(final_poly), 1);
     -- challenger continuation: observe all opened values (coms_to_verify
     -- order), built as one front-to-back suffix + a single concat (the input
@@ -1041,9 +1284,14 @@ def pcs := ⟦
     -- max height so `two_adic_gen`'s squaring chain (bits ≤ 32) and the
     -- 32-bit query-index decomposition stay within range.
     assert_eq!(u32_less_than(log_gmax, 33), 1);
-    query_loop(input, output, query_proofs, alpha, stage1, stage2, q_opened,
+    let indices = sample_query_indices(input, output, num_queries, log_gmax);
+    assert_eq!(verify_input_multi(input_openings, indices, s1c, s2c, qc,
+      prep_commit, prep_opt, prep_indices, log_degrees, num_circuits, log_blowup, log_gmax), 1);
+    let query_proofs = query_views(input_openings, commit_phase_openings, 0, num_queries);
+    let fri_rows = query_loop(input, output, query_proofs, alpha, stage1, stage2, q_opened,
       prep_opt, s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta,
-      num_circuits, log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds)
+      num_circuits, log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds);
+    verify_commit_multi(commit_phase_openings, commit_phase_commits, fri_rows, indices, 0, log_gmax)
   }
 
 ⟧
diff --git a/Ix/MultiStark/Verifier.lean b/Ix/MultiStark/Verifier.lean
index b11b6a79e..5e72fd32c 100644
--- a/Ix/MultiStark/Verifier.lean
+++ b/Ix/MultiStark/Verifier.lean
@@ -871,9 +871,17 @@ def verifier := ⟦
     -- `query_pow_bits`) all come from the verifying key, which the public
     -- statement binds through `system_digest` — no separate public inputs.
     let Sys.Mk(params, tlimbs, circuits, commit, prep_indices) = sys;
-    let SysParams.Mk(log_blowup, _cap_height, _log_final_poly_len,
-                     _max_log_arity, num_queries, commit_pow_bits,
+    let SysParams.Mk(log_blowup, cap_height, log_final_poly_len,
+                     max_log_arity, num_queries, commit_pow_bits,
                      query_pow_bits) = params;
+    -- This recursive verifier is deliberately specialized to root caps,
+    -- binary FRI folds, and a constant final polynomial. These parameters are
+    -- digest-bound but still prover-visible inputs to this circuit, so reject
+    -- unsupported systems explicitly instead of silently applying the wrong
+    -- Merkle geometry or folding semantics.
+    assert_eq!(cap_height, 0);
+    assert_eq!(log_final_poly_len, 0);
+    assert_eq!(max_log_arity, 1);
     let Proof.Mk(active, commitments, accs, log_degrees, opening,
                  q_opened, prep_opt, stage1, stage2) = proof;
     -- Sparse activation: the bitmap covers the canonical circuit set;
diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean
index 26d62327d..b62c08414 100644
--- a/Tests/MultiStark.lean
+++ b/Tests/MultiStark.lean
@@ -157,7 +157,9 @@ def endToEndSuite : IO UInt32 := do
     | .ok result => pure result
     | .error e => IO.eprintln s!"factorial prove failed: {e}"; return 1
   let expectedClaim := buildClaim facIdx input #[Aiur.G.ofNat 120]
-  let proofBytes := proof.toBytes
+  let proofBytes ← match facSystem.proofToAdviceBytes claim proof with
+    | .ok bytes => pure bytes
+    | .error e => IO.eprintln s!"advice re-encoding failed: {e}"; return 1
 
   -- ── serialize proof (advice) + vk + claims, with public Blake3 digests ──
   let proofGs : Array Aiur.G := proofBytes.data.map .ofUInt8
@@ -187,10 +189,16 @@ def endToEndSuite : IO UInt32 := do
     | none => IO.eprintln "verify_multi_stark_proof entrypoint not found"; return 1
 
   -- ── negative-test inputs ────────────────────────────────────────────────────
-  -- Tampered proof advice: flip byte 0 (the first stage_1-commitment limb) so the
-  -- replayed Fiat-Shamir transcript diverges from the one the proof was made under.
+  -- Tampered proof advice: locate the first stage-1 commitment byte after the
+  -- native proof's `Vec<bool>` activation bitmap and cap-length prefix. This
+  -- keeps the proof structurally parseable while forcing Fiat-Shamir and the
+  -- Merkle checks away from the proof that was actually produced.
+  let activeLen := (List.range 8).foldl (fun n i =>
+    n ||| (proofBytes.data[i]!.toUInt64 <<< (i * 8).toUInt64)) 0
+  let firstCommitByte := 8 + activeLen.toNat + 8
   let badProofBytes :=
-    proofBytes.set! 0 (UInt8.ofNat ((proofBytes.data[0]!.toNat + 1) % 256))
+    proofBytes.set! firstCommitByte
+      (UInt8.ofNat ((proofBytes.data[firstCommitByte]!.toNat + 1) % 256))
   -- Tampered claim (with a matching keccak digest): 120 → 121. Feeds a different
   -- value into Fiat-Shamir (→ different ζ) and the lookup accumulator, so the
   -- composition/quotient identity no longer holds even though the binding passes.
@@ -201,7 +209,7 @@ def endToEndSuite : IO UInt32 := do
 
   -- ── run the (expensive) checks, then assert ─────────────────────────────────
   IO.println "recursive-verifier (proving + recursive verification, ~1.5 min)…"
-  let innerVerify := facSystem.verify claim (.ofBytes proofBytes)
+  let innerVerify := facSystem.verify claim (.ofBytes proof.toBytes)
   -- Native path: Rust-built advice buffer + codegen'd verifier
   -- (`crates/ixvm-codegen/src/aiur_multi_stark.rs`).
   let honest :=
diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs
index 3037a1d52..d5d847c95 100644
--- a/crates/aiur/src/execute.rs
+++ b/crates/aiur/src/execute.rs
@@ -209,7 +209,7 @@ fn dump_query_stats(record: &QueryRecord, tag: &str) {
     .map(|(i, m)| (i, m.len(), m.retained_elems()))
     .filter(|(_, n, _)| *n > 0)
     .collect();
-  rows.sort_by(|a, b| b.2.cmp(&a.2));
+  rows.sort_by_key(|row| std::cmp::Reverse(row.2));
   let total_entries: usize = rows.iter().map(|r| r.1).sum();
   let total_elems: usize = rows.iter().map(|r| r.2).sum();
   eprintln!(
@@ -1053,7 +1053,9 @@ fn biguint_to_klimbs_u64(n: &num_bigint::BigUint) -> Vec<u64> {
     bytes.push(0);
   }
   bytes
-    .chunks_exact(8)
+    .as_chunks::<8>()
+    .0
+    .iter()
     .map(|c| {
       let mut a = [0u8; 8];
       a.copy_from_slice(c);
diff --git a/crates/aiur/src/gadgets/bytes1.rs b/crates/aiur/src/gadgets/bytes1.rs
index 667cb8ad9..e3acd1552 100644
--- a/crates/aiur/src/gadgets/bytes1.rs
+++ b/crates/aiur/src/gadgets/bytes1.rs
@@ -49,8 +49,12 @@ impl AiurGadget for Bytes1 {
   /// Builds the preprocessed trace over all 256 byte values.
   fn preprocessed(&self) -> Option<RowMajorMatrix<G>> {
     let mut values = vec![G::ZERO; 256 * PREPROCESSED_TRACE_WIDTH];
-    values.chunks_exact_mut(PREPROCESSED_TRACE_WIDTH).enumerate().for_each(
-      |(i, row)| {
+    values
+      .as_chunks_mut::<PREPROCESSED_TRACE_WIDTH>()
+      .0
+      .iter_mut()
+      .enumerate()
+      .for_each(|(i, row)| {
         let byte = G::from_usize(i);
 
         // Raw byte value
@@ -68,8 +72,7 @@ impl AiurGadget for Bytes1 {
 
         // Byte shifted right
         row[10] = Self::shift_right(&byte);
-      },
-    );
+      });
     Some(RowMajorMatrix::new(values, PREPROCESSED_TRACE_WIDTH))
   }
 
@@ -168,7 +171,9 @@ impl AiurGadget for Bytes1 {
 
     // There are at most 256 rows so parallelism is not necessay.
     rows
-      .chunks_exact_mut(TRACE_WIDTH)
+      .as_chunks_mut::<TRACE_WIDTH>()
+      .0
+      .iter_mut()
       .enumerate()
       .zip(&record.bytes1_queries.0)
       .zip(row_writers.iter_mut())
diff --git a/crates/aiur/src/gadgets/bytes2.rs b/crates/aiur/src/gadgets/bytes2.rs
index 8a2e16ef4..e013a6a34 100644
--- a/crates/aiur/src/gadgets/bytes2.rs
+++ b/crates/aiur/src/gadgets/bytes2.rs
@@ -304,7 +304,9 @@ impl AiurGadget for Bytes2 {
     let xor_split4_channel = u8_xor_split4_channel();
 
     rows
-      .chunks_exact_mut(TRACE_WIDTH)
+      .as_chunks_mut::<TRACE_WIDTH>()
+      .0
+      .iter_mut()
       .enumerate()
       .zip(&record.bytes2_queries.0)
       .zip(row_writers.iter_mut())
diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs
index 552743c28..3e833a752 100644
--- a/crates/aiur/src/synthesis.rs
+++ b/crates/aiur/src/synthesis.rs
@@ -443,6 +443,17 @@ impl AiurSystem {
   ) -> Result<(), VerificationError<PcsError>> {
     self.system.verify(claim, proof)
   }
+
+  /// Verify and serialize the native Plonky3 multiproof for the in-circuit
+  /// recursive verifier.
+  pub fn proof_to_advice_bytes(
+    &self,
+    claim: &[G],
+    proof: &AiurProof,
+  ) -> Result<Vec<u8>, String> {
+    self.verify(claim, proof).map_err(|e| format!("{e:?}"))?;
+    proof.to_bytes().map_err(|e| format!("{e:?}"))
+  }
 }
 
 #[cfg(test)]
diff --git a/crates/common/src/address.rs b/crates/common/src/address.rs
index 334aafd13..0bc032456 100644
--- a/crates/common/src/address.rs
+++ b/crates/common/src/address.rs
@@ -46,10 +46,12 @@ impl Address {
   }
 
   /// Iterate addresses out of a flat `[u8; 32 * N]` byte blob. Trailing
-  /// bytes shorter than 32 are silently dropped (via `chunks_exact`).
+  /// bytes shorter than 32 are silently dropped.
   pub fn unpack(bytes: &[u8]) -> impl Iterator<Item = Address> + '_ {
     bytes
-      .chunks_exact(32)
+      .as_chunks::<32>()
+      .0
+      .iter()
       .map(|c| Address::from_slice(c).expect("malformed address chunk"))
   }
 
diff --git a/crates/compile/src/compile.rs b/crates/compile/src/compile.rs
index b07bb3526..cae62d132 100644
--- a/crates/compile/src/compile.rs
+++ b/crates/compile/src/compile.rs
@@ -1209,7 +1209,7 @@ pub fn compile_expr(
                       });
                     }
                     let n_specs = specs.len();
-                    canonical_args.extend(specs.into_iter());
+                    canonical_args.extend(specs);
                     for (src_i, motive) in motives.iter().enumerate() {
                       if plan.motive_keep[src_i] {
                         canonical_args.push(motive.clone());
diff --git a/crates/compile/src/compile/aux_gen/brecon.rs b/crates/compile/src/compile/aux_gen/brecon.rs
index ee9134edb..da2db5172 100644
--- a/crates/compile/src/compile/aux_gen/brecon.rs
+++ b/crates/compile/src/compile/aux_gen/brecon.rs
@@ -510,8 +510,7 @@ fn build_prop_below_minor_fvar(
   let mut lambda_fvars: Vec<LeanExpr> = Vec::new();
   let mut ctor_args: Vec<LeanExpr> = Vec::new();
 
-  for (fi, (decl, fvar)) in
-    field_decls.into_iter().zip(field_fvars.into_iter()).enumerate()
+  for (fi, (decl, fvar)) in field_decls.into_iter().zip(field_fvars).enumerate()
   {
     if let Some(j_prime) = find_motive_fvar(&decl.domain, motive_fvars) {
       // IH field. For a non-reflexive IH `motive args`, the new binder is
@@ -1134,8 +1133,7 @@ fn build_type_minor_premise_fvar(
   let mut lambda_fvars: Vec<LeanExpr> = Vec::new();
   let mut prod_entries: Vec<(LeanExpr, usize)> = Vec::new(); // (fvar, lambda_index) for IH fields
 
-  for (fi, (decl, fvar)) in
-    field_decls.into_iter().zip(field_fvars.into_iter()).enumerate()
+  for (fi, (decl, fvar)) in field_decls.into_iter().zip(field_fvars).enumerate()
   {
     if let Some(_j_prime) = find_motive_fvar(&decl.domain, motive_fvars) {
       // IH field: replace domain with PProd(motive, below)
diff --git a/crates/compile/src/compile/aux_gen/cases_on.rs b/crates/compile/src/compile/aux_gen/cases_on.rs
index bad60eee0..096891920 100644
--- a/crates/compile/src/compile/aux_gen/cases_on.rs
+++ b/crates/compile/src/compile/aux_gen/cases_on.rs
@@ -191,7 +191,7 @@ pub fn generate_cases_on(
       let mut non_ih_fvars: Vec<LeanExpr> = Vec::new();
       let mut wrapper_decls: Vec<LocalDecl> = Vec::new(); // all fields for the rec lambda
 
-      for (decl, fvar) in field_decls.into_iter().zip(field_fvars.into_iter()) {
+      for (decl, fvar) in field_decls.into_iter().zip(field_fvars) {
         let motive_idx = find_motive_fvar(&decl.domain, &motive_fvars);
         if let Some(idx) = motive_idx {
           if idx == target_idx {
diff --git a/crates/compile/src/compile/env.rs b/crates/compile/src/compile/env.rs
index 2f4afa9f3..b30545b82 100644
--- a/crates/compile/src/compile/env.rs
+++ b/crates/compile/src/compile/env.rs
@@ -397,7 +397,7 @@ pub fn compile_env_with_options(
   // Use scoped threads to borrow from parent scope. `IX_COMPILE_WORKERS`
   // gives large-env callers a simple peak-memory/speed tradeoff knob.
   let available_threads =
-    thread::available_parallelism().map(|n| n.get()).unwrap_or(4);
+    thread::available_parallelism().map_or(4, |n| n.get());
   let requested_threads = options.max_workers.or_else(|| {
     std::env::var("IX_COMPILE_WORKERS")
       .ok()
diff --git a/crates/compile/src/compile/mutual.rs b/crates/compile/src/compile/mutual.rs
index 17a67882a..e62050590 100644
--- a/crates/compile/src/compile/mutual.rs
+++ b/crates/compile/src/compile/mutual.rs
@@ -712,8 +712,8 @@ pub fn generate_and_compile_aux_recursors(
   // `populate_recursor_rules_from_block` comment in the kernel.
   let t1 = std::time::Instant::now();
   let rec_consts: Vec<MutConst> = patches
-    .iter()
-    .filter_map(|(_, p)| match p {
+    .values()
+    .filter_map(|p| match p {
       PatchedConstant::Rec(r) => Some(MutConst::Recr(r.clone())),
       _ => None,
     })
@@ -822,8 +822,8 @@ pub fn generate_and_compile_aux_recursors(
   // (because .brecOn.eq references casesOn).
   let t2 = std::time::Instant::now();
   let cases_on_defs: Vec<MutConst> = patches
-    .iter()
-    .filter_map(|(_, p)| match p {
+    .values()
+    .filter_map(|p| match p {
       PatchedConstant::CasesOn(d) => Some(MutConst::Defn(Def {
         name: d.name.clone(),
         level_params: d.level_params.clone(),
@@ -846,8 +846,8 @@ pub fn generate_and_compile_aux_recursors(
   // recOn wraps .rec and must be compiled after .rec.
   let t3 = std::time::Instant::now();
   let rec_on_defs: Vec<MutConst> = patches
-    .iter()
-    .filter_map(|(_, p)| match p {
+    .values()
+    .filter_map(|p| match p {
       PatchedConstant::RecOn(d) => Some(MutConst::Defn(Def {
         name: d.name.clone(),
         level_params: d.level_params.clone(),
@@ -887,8 +887,8 @@ pub fn generate_and_compile_aux_recursors(
   // order with the canonical `all`.
   let t4 = std::time::Instant::now();
   let mut below_raw: Vec<&BelowIndc> = patches
-    .iter()
-    .filter_map(|(_, p)| match p {
+    .values()
+    .filter_map(|p| match p {
       PatchedConstant::BelowIndc(bi) => Some(bi),
       _ => None,
     })
@@ -932,8 +932,8 @@ pub fn generate_and_compile_aux_recursors(
 
   // Phase 4: Compile .below definitions (Type-level).
   let below_defs: Vec<MutConst> = patches
-    .iter()
-    .filter_map(|(_, p)| match p {
+    .values()
+    .filter_map(|p| match p {
       PatchedConstant::BelowDef(d) => Some(MutConst::Defn(Def {
         name: d.name.clone(),
         level_params: d.level_params.clone(),
@@ -970,8 +970,8 @@ pub fn generate_and_compile_aux_recursors(
   let t6 = std::time::Instant::now();
   for batch in 0..3u8 {
     let defs: Vec<MutConst> = patches
-      .iter()
-      .filter_map(|(_, p)| match p {
+      .values()
+      .filter_map(|p| match p {
         PatchedConstant::BRecOn(d) if brecon_batch(&d.name) == batch => {
           Some(brecon_to_mut_const(d))
         },
diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs
index 9adb0cd3c..4247d342a 100644
--- a/crates/ffi/src/aiur/protocol.rs
+++ b/crates/ffi/src/aiur/protocol.rs
@@ -143,6 +143,21 @@ extern "C" fn rs_aiur_system_verify(
   }
 }
 
+/// `AiurSystem.proofToAdviceBytes`: expand a valid pruned FRI multiproof into
+/// the per-query advice transport consumed by the recursive verifier.
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_proof_to_advice_bytes(
+  aiur_system_obj: LeanExternal<AiurSystem, LeanBorrowed<'_>>,
+  claim: LeanArray<LeanBorrowed<'_>>,
+  proof_obj: LeanExternal<AiurProof, LeanBorrowed<'_>>,
+) -> LeanExcept<LeanOwned> {
+  let claim = claim.map(|x| lean_unbox_g(&x));
+  match aiur_system_obj.get().proof_to_advice_bytes(&claim, proof_obj.get()) {
+    Ok(bytes) => LeanExcept::ok(LeanByteArray::from_bytes(&bytes)),
+    Err(err) => LeanExcept::error_string(&err),
+  }
+}
+
 /// `Bytecode.Toplevel.execute`: runs execution only (no proof) and returns
 /// `Except String ExecuteResult` (see `Ix/Aiur/Semantics/BytecodeFfi.lean`).
 /// On execution failure (e.g. assertion mismatch from a typechecker
@@ -402,7 +417,9 @@ fn decode_owned_blob(
   }
   Ok(
     bytes
-      .chunks_exact(32)
+      .as_chunks::<32>()
+      .0
+      .iter()
       .map(|c| ix_common::address::Address::from_slice(c).unwrap())
       .collect(),
   )
@@ -685,7 +702,9 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch(
       }
       shards.push(
         bytes[off..off + n * 32]
-          .chunks_exact(32)
+          .as_chunks::<32>()
+          .0
+          .iter()
           .map(|c| ix_common::address::Address::from_slice(c).unwrap())
           .collect(),
       );
diff --git a/crates/ffi/src/catalog.rs b/crates/ffi/src/catalog.rs
index 6384a5836..f62e9ceef 100644
--- a/crates/ffi/src/catalog.rs
+++ b/crates/ffi/src/catalog.rs
@@ -127,9 +127,8 @@ pub extern "C" fn rs_catalog_assemble(
       return LeanIOResult::error_string(&format!("rs_catalog_assemble: {e}"));
     },
   };
-  let manifest_bytes = std::fs::metadata(dir.join(cat::MANIFEST_FILE))
-    .map(|m| m.len())
-    .unwrap_or(0);
+  let manifest_bytes =
+    std::fs::metadata(dir.join(cat::MANIFEST_FILE)).map_or(0, |m| m.len());
   let mut summary = catalog_json(&catalog);
   summary["bytes"] = serde_json::json!(manifest_bytes);
   summary["out"] = serde_json::json!(out_path);
@@ -196,9 +195,8 @@ pub extern "C" fn rs_catalog_info(
       return LeanIOResult::error_string(&format!("rs_catalog_info: {e}"));
     },
   };
-  let manifest_bytes = std::fs::metadata(dir.join(cat::MANIFEST_FILE))
-    .map(|m| m.len())
-    .unwrap_or(0);
+  let manifest_bytes =
+    std::fs::metadata(dir.join(cat::MANIFEST_FILE)).map_or(0, |m| m.len());
   let mut summary = catalog_json(&catalog);
   summary["bytes"] = serde_json::json!(manifest_bytes);
   LeanIOResult::ok(LeanString::new(&summary.to_string()))
diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs
index 2185cad47..2b7807124 100644
--- a/crates/ffi/src/kernel.rs
+++ b/crates/ffi/src/kernel.rs
@@ -1296,7 +1296,7 @@ where
 fn resolve_kernel_check_workers(total: usize, quiet: bool) -> usize {
   let env_workers = std::env::var("IX_KERNEL_CHECK_WORKERS").ok();
   let no_par = std::env::var("IX_NO_PAR").ok().as_deref() == Some("1");
-  let available = thread::available_parallelism().map(|n| n.get()).unwrap_or(1);
+  let available = thread::available_parallelism().map_or(1, |n| n.get());
   resolve_kernel_check_workers_from(
     total,
     quiet,
diff --git a/crates/ffi/src/lean_env.rs b/crates/ffi/src/lean_env.rs
index 55dee3058..6c48ef5e6 100644
--- a/crates/ffi/src/lean_env.rs
+++ b/crates/ffi/src/lean_env.rs
@@ -4362,7 +4362,7 @@ fn analyze_const_size(stt: &ix_compile::compile::CompileState, name_str: &str) {
   }
 
   // Sort by total size descending
-  dep_breakdowns.sort_by(|a, b| b.1.total().cmp(&a.1.total()));
+  dep_breakdowns.sort_by_key(|entry| std::cmp::Reverse(entry.1.total()));
 
   let total_deps_alpha: usize =
     dep_breakdowns.iter().map(|(_, b)| b.alpha_size).sum();
@@ -4566,7 +4566,7 @@ fn analyze_block_size_stats(stt: &ix_compile::compile::CompileState) {
     .collect();
 
   // Sort by overhead descending (most bloated first)
-  overheads.sort_by(|a, b| b.1.cmp(&a.1));
+  overheads.sort_by_key(|entry| std::cmp::Reverse(entry.1));
 
   // Compute statistics
   let avg_ratio = if total_hash_consed > 0 {
diff --git a/crates/ffi/src/lean_ixon/sharing.rs b/crates/ffi/src/lean_ixon/sharing.rs
index 9811fb63d..f49218f49 100644
--- a/crates/ffi/src/lean_ixon/sharing.rs
+++ b/crates/ffi/src/lean_ixon/sharing.rs
@@ -36,7 +36,7 @@ pub extern "C" fn rs_debug_sharing_analysis(
     .collect();
 
   // Sort by usage count descending
-  candidates.sort_by(|a, b| b.1.usage_count.cmp(&a.1.usage_count));
+  candidates.sort_by_key(|entry| std::cmp::Reverse(entry.1.usage_count));
 
   println!("[Rust] Subterms with usage >= 2:");
   for (hash, info, eff_size) in candidates {
diff --git a/crates/ixon/src/diff.rs b/crates/ixon/src/diff.rs
index bc162f10d..3e39b4d5e 100644
--- a/crates/ixon/src/diff.rs
+++ b/crates/ixon/src/diff.rs
@@ -2549,7 +2549,7 @@ mod tests {
     let index = Env::parse_lazy_index(&bytes).expect("lazy index");
     let mut sizes: Vec<(usize, Address)> =
       index.consts.iter().map(|c| (c.len, c.addr.clone())).collect();
-    sizes.sort_by(|a, b| b.0.cmp(&a.0));
+    sizes.sort_by_key(|entry| std::cmp::Reverse(entry.0));
     let total: usize = sizes.iter().map(|(l, _)| *l).sum();
     println!("consts: {} total bytes: {}", sizes.len(), total);
     for (len, addr) in sizes.iter().take(top) {
diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs
index b413a2dbd..a0965d7ee 100644
--- a/crates/ixvm-codegen/src/aiur_ixvm.rs
+++ b/crates/ixvm-codegen/src/aiur_ixvm.rs
@@ -25,6 +25,25 @@ fn aiur_fn_0(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_0], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+    let __ret: [G; OUT_0] = [__v_2];
+    if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_1: usize = 2;
+const IN_1: usize = 2;
+const OUT_1: usize = 1;
+fn aiur_fn_1(
+  inp: [G; IN_1],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_1], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -266,61 +285,61 @@ fn aiur_fn_0(
                     match __v_226.as_canonical_u64() {
                       0u64 => {
                         let __v_227: G = G::from_u64(1);
-                        let __ret: [G; OUT_0] = [__v_227];
-                        if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_1] = [__v_227];
+                        if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_227: G = G::from_u64(0);
-                        let __ret: [G; OUT_0] = [__v_227];
-                        if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_1] = [__v_227];
+                        if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_214: G = G::from_u64(0);
-                    let __ret: [G; OUT_0] = [__v_214];
-                    if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_1] = [__v_214];
+                    if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_177: G = G::from_u64(0);
-                let __ret: [G; OUT_0] = [__v_177];
-                if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_1] = [__v_177];
+                if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_140: G = G::from_u64(0);
-            let __ret: [G; OUT_0] = [__v_140];
-            if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_1] = [__v_140];
+            if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_103: G = G::from_u64(0);
-        let __ret: [G; OUT_0] = [__v_103];
-        if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_1] = [__v_103];
+        if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_1: usize = 2;
-const IN_1: usize = 2;
-const OUT_1: usize = 1;
-fn aiur_fn_1(
-  inp: [G; IN_1],
+const INPUT_SIZE_2: usize = 2;
+const IN_2: usize = 2;
+const OUT_2: usize = 1;
+fn aiur_fn_2(
+  inp: [G; IN_2],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_1], ExecError> {
+) -> Result<[G; OUT_2], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -393,31 +412,31 @@ fn aiur_fn_1(
     let __v_66: G = (__v_2 - __v_34);
     match __v_66.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
         let __v_67: G = __r_arr[0];
-        let __ret: [G; OUT_1] = [__v_67];
-        if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_2] = [__v_67];
+        if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_67: G = G::from_u64(0);
-        let __ret: [G; OUT_1] = [__v_67];
-        if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_2] = [__v_67];
+        if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_2: usize = 3;
-const IN_2: usize = 3;
-const OUT_2: usize = 1;
-fn aiur_fn_2(
-  inp: [G; IN_2],
+const INPUT_SIZE_3: usize = 3;
+const IN_3: usize = 3;
+const OUT_3: usize = 1;
+fn aiur_fn_3(
+  inp: [G; IN_3],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_2], ExecError> {
+) -> Result<[G; OUT_3], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -427,8 +446,8 @@ fn aiur_fn_2(
         let __v_3: G = G::from_u64(1);
         let __v_4: G = G::from_u64(1);
         let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_2] = [__v_5];
-        if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_3] = [__v_5];
+        if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -436,29 +455,29 @@ fn aiur_fn_2(
         let __v_4: G = (__v_1 + __v_3);
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_2 - __v_5);
-        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr };
         let __v_8: G = __io_read[0];
         let __v_9: G = G::from_u64(0);
         let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_2] = [__v_10];
-        if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_3] = [__v_10];
+        if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_3: usize = 8;
-const IN_3: usize = 8;
-const OUT_3: usize = 1;
-fn aiur_fn_3(
-  inp: [G; IN_3],
+const INPUT_SIZE_4: usize = 8;
+const IN_4: usize = 8;
+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_3], ExecError> {
+) -> 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];
@@ -483,14 +502,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(1);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -499,14 +518,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -519,14 +538,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -535,14 +554,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -559,14 +578,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -575,14 +594,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -595,14 +614,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -611,14 +630,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -639,14 +658,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(4);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -655,14 +674,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -675,14 +694,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -691,14 +710,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -715,14 +734,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -731,14 +750,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -751,14 +770,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -767,14 +786,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -799,14 +818,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(3);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -815,14 +834,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -835,14 +854,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -851,14 +870,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -875,14 +894,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -891,14 +910,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -911,14 +930,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -927,14 +946,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -955,14 +974,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(4);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -971,14 +990,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -991,14 +1010,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1007,14 +1026,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1031,14 +1050,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1047,14 +1066,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1067,14 +1086,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1083,14 +1102,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1119,14 +1138,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(2);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1135,14 +1154,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1155,14 +1174,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1171,14 +1190,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1195,14 +1214,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1211,14 +1230,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1231,14 +1250,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1247,14 +1266,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1275,14 +1294,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(4);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1291,14 +1310,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1311,14 +1330,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1327,14 +1346,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1351,14 +1370,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1367,14 +1386,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1387,14 +1406,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1403,14 +1422,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1435,14 +1454,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(3);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1451,14 +1470,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1471,14 +1490,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1487,14 +1506,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1511,14 +1530,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1527,14 +1546,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1547,14 +1566,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1563,14 +1582,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1591,14 +1610,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(4);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1607,14 +1626,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1627,14 +1646,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1643,14 +1662,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1667,14 +1686,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1683,14 +1702,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1703,14 +1722,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1719,14 +1738,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -1745,15 +1764,15 @@ fn aiur_fn_3(
   })
 }
 
-const INPUT_SIZE_4: usize = 8;
-const IN_4: usize = 8;
-const OUT_4: usize = 1;
-fn aiur_fn_4(
-  inp: [G; IN_4],
+const INPUT_SIZE_5: usize = 8;
+const IN_5: usize = 8;
+const OUT_5: usize = 1;
+fn aiur_fn_5(
+  inp: [G; IN_5],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_4], 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];
@@ -1780,85 +1799,85 @@ fn aiur_fn_4(
                                 match __v_7.as_canonical_u64() {
                                   0u64 => {
                                     let __v_8: G = G::from_u64(1);
-                                    let __ret: [G; OUT_4] = [__v_8];
-                                    if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_5] = [__v_8];
+                                    if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                   _ => {
                                     let __v_8: G = G::from_u64(0);
-                                    let __ret: [G; OUT_4] = [__v_8];
-                                    if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_5] = [__v_8];
+                                    if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(0);
-                                let __ret: [G; OUT_4] = [__v_8];
-                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_5] = [__v_8];
+                                if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
                             let __v_8: G = G::from_u64(0);
-                            let __ret: [G; OUT_4] = [__v_8];
-                            if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_5] = [__v_8];
+                            if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_8: G = G::from_u64(0);
-                        let __ret: [G; OUT_4] = [__v_8];
-                        if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_5] = [__v_8];
+                        if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_8: G = G::from_u64(0);
-                    let __ret: [G; OUT_4] = [__v_8];
-                    if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_5] = [__v_8];
+                    if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_8: G = G::from_u64(0);
-                let __ret: [G; OUT_4] = [__v_8];
-                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_5] = [__v_8];
+                if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_4] = [__v_8];
-            if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_5] = [__v_8];
+            if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_4] = [__v_8];
-        if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_5] = [__v_8];
+        if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].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],
+const INPUT_SIZE_6: usize = 8;
+const IN_6: usize = 8;
+const OUT_6: usize = 4;
+fn aiur_fn_6(
+  inp: [G; IN_6],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_5], 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];
@@ -1881,61 +1900,14 @@ fn aiur_fn_5(
     if (__v_13 != __v_12) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
     }
-    let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11];
-    if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_6: usize = 12;
-const IN_6: usize = 12;
-const OUT_6: usize = 4;
-fn aiur_fn_6(
-  inp: [G; IN_6],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_6], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))) + u128::from(((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8) | (__v_10.as_canonical_u64() << 16) | (__v_11.as_canonical_u64() << 24)));
-    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
-    let __v_12: G = G::from_u8(__u32_bytes[0]);
-    let __v_13: G = G::from_u8(__u32_bytes[1]);
-    let __v_14: G = G::from_u8(__u32_bytes[2]);
-    let __v_15: G = G::from_u8(__u32_bytes[3]);
-    let __v_16: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
-    if !unconstrained { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_14; let __vj = __v_15; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_17: G = G::from_u64(1);
-    let __v_18: G = (__v_16 - __v_17);
-    let __v_19: G = G::from_u64(2);
-    let __v_20: G = (__v_16 - __v_19);
-    let __v_21: G = (__v_18 * __v_20);
-    let __v_22: G = (__v_16 * __v_21);
-    let __v_23: G = G::from_u64(0);
-    if (__v_22 != __v_23) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
-    }
-    let __ret: [G; OUT_6] = [__v_12, __v_13, __v_14, __v_15];
+    let __ret: [G; OUT_6] = [__v_8, __v_9, __v_10, __v_11];
     if let Some(result) = record.function_queries[6].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_7: usize = 8;
-const IN_7: usize = 8;
+const INPUT_SIZE_7: usize = 12;
+const IN_7: usize = 12;
 const OUT_7: usize = 4;
 fn aiur_fn_7(
   inp: [G; IN_7],
@@ -1952,18 +1924,37 @@ fn aiur_fn_7(
     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_7] = [__v_8, __v_9, __v_10, __v_11];
+    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 __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))) + u128::from(((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8) | (__v_10.as_canonical_u64() << 16) | (__v_11.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_12: G = G::from_u8(__u32_bytes[0]);
+    let __v_13: G = G::from_u8(__u32_bytes[1]);
+    let __v_14: G = G::from_u8(__u32_bytes[2]);
+    let __v_15: G = G::from_u8(__u32_bytes[3]);
+    let __v_16: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_14; let __vj = __v_15; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_17: G = G::from_u64(1);
+    let __v_18: G = (__v_16 - __v_17);
+    let __v_19: G = G::from_u64(2);
+    let __v_20: G = (__v_16 - __v_19);
+    let __v_21: G = (__v_18 * __v_20);
+    let __v_22: G = (__v_16 * __v_21);
+    let __v_23: G = G::from_u64(0);
+    if (__v_22 != __v_23) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __ret: [G; OUT_7] = [__v_12, __v_13, __v_14, __v_15];
     if let Some(result) = record.function_queries[7].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_8: usize = 4;
-const IN_8: usize = 4;
+const INPUT_SIZE_8: usize = 8;
+const IN_8: usize = 8;
 const OUT_8: usize = 4;
 fn aiur_fn_8(
   inp: [G; IN_8],
@@ -1976,7 +1967,15 @@ fn aiur_fn_8(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __ret: [G; OUT_8] = [__v_2, __v_3, __v_0, __v_1];
+    let __v_4: G = 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_8] = [__v_8, __v_9, __v_10, __v_11];
     if let Some(result) = record.function_queries[8].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
@@ -1996,14 +1995,14 @@ fn aiur_fn_9(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __ret: [G; OUT_9] = [__v_1, __v_2, __v_3, __v_0];
+    let __ret: [G; OUT_9] = [__v_2, __v_3, __v_0, __v_1];
     if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_10: usize = 8;
-const IN_10: usize = 8;
+const INPUT_SIZE_10: usize = 4;
+const IN_10: usize = 4;
 const OUT_10: usize = 4;
 fn aiur_fn_10(
   inp: [G; IN_10],
@@ -2011,6 +2010,26 @@ fn aiur_fn_10(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_10], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __ret: [G; OUT_10] = [__v_1, __v_2, __v_3, __v_0];
+    if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_11: usize = 8;
+const IN_11: usize = 8;
+const OUT_11: usize = 4;
+fn aiur_fn_11(
+  inp: [G; IN_11],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_11], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2036,21 +2055,21 @@ fn aiur_fn_10(
     let __v_17: G = (__v_10 + __v_13);
     let __v_18: G = (__v_12 + __v_15);
     let __v_19: G = (__v_14 + __v_9);
-    let __ret: [G; OUT_10] = [__v_16, __v_17, __v_18, __v_19];
-    if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19];
+    if let Some(result) = record.function_queries[11].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_11: usize = 8;
-const IN_11: usize = 8;
-const OUT_11: usize = 4;
-fn aiur_fn_11(
-  inp: [G; IN_11],
+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_11], ExecError> {
+) -> 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];
@@ -2076,21 +2095,21 @@ fn aiur_fn_11(
     let __v_17: G = (__v_12 + __v_15);
     let __v_18: G = (__v_14 + __v_9);
     let __v_19: G = (__v_8 + __v_11);
-    let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19];
-    if let Some(result) = record.function_queries[11].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_12] = [__v_16, __v_17, __v_18, __v_19];
+    if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_12: usize = 16;
-const IN_12: usize = 16;
-const OUT_12: usize = 1;
-fn aiur_fn_12(
-  inp: [G; IN_12],
+const INPUT_SIZE_13: usize = 16;
+const IN_13: usize = 16;
+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_12], ExecError> {
+) -> Result<[G; OUT_13], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2133,85 +2152,85 @@ fn aiur_fn_12(
                                 match __v_23.as_canonical_u64() {
                                   0u64 => {
                                     let __v_24: G = G::from_u64(1);
-                                    let __ret: [G; OUT_12] = [__v_24];
-                                    if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_13] = [__v_24];
+                                    if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                   _ => {
                                     let __v_24: G = G::from_u64(0);
-                                    let __ret: [G; OUT_12] = [__v_24];
-                                    if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_13] = [__v_24];
+                                    if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
                                 let __v_24: G = G::from_u64(0);
-                                let __ret: [G; OUT_12] = [__v_24];
-                                if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_13] = [__v_24];
+                                if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
                             let __v_24: G = G::from_u64(0);
-                            let __ret: [G; OUT_12] = [__v_24];
-                            if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_13] = [__v_24];
+                            if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_24: G = G::from_u64(0);
-                        let __ret: [G; OUT_12] = [__v_24];
-                        if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_13] = [__v_24];
+                        if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_24: G = G::from_u64(0);
-                    let __ret: [G; OUT_12] = [__v_24];
-                    if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_13] = [__v_24];
+                    if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_24: G = G::from_u64(0);
-                let __ret: [G; OUT_12] = [__v_24];
-                if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_13] = [__v_24];
+                if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_24: G = G::from_u64(0);
-            let __ret: [G; OUT_12] = [__v_24];
-            if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_13] = [__v_24];
+            if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_24: G = G::from_u64(0);
-        let __ret: [G; OUT_12] = [__v_24];
-        if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_13] = [__v_24];
+        if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_13: usize = 16;
-const IN_13: usize = 16;
-const OUT_13: usize = 9;
-fn aiur_fn_13(
-  inp: [G; IN_13],
+const INPUT_SIZE_14: usize = 16;
+const IN_14: usize = 16;
+const OUT_14: usize = 9;
+fn aiur_fn_14(
+  inp: [G; IN_14],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_13], ExecError> {
+) -> Result<[G; OUT_14], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2281,21 +2300,21 @@ fn aiur_fn_13(
     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_13] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
-    if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_14] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
+    if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].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 = 8;
-fn aiur_fn_14(
-  inp: [G; IN_14],
+const INPUT_SIZE_15: usize = 8;
+const IN_15: usize = 8;
+const OUT_15: usize = 8;
+fn aiur_fn_15(
+  inp: [G; IN_15],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_14], 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];
@@ -2329,8 +2348,8 @@ fn aiur_fn_14(
                                     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_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-                                    if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+                                    if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -2343,8 +2362,8 @@ fn aiur_fn_14(
                                     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_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
-                                    if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
+                                    if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                 }
@@ -2358,8 +2377,8 @@ fn aiur_fn_14(
                                 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_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
-                                if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
+                                if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -2372,8 +2391,8 @@ fn aiur_fn_14(
                             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_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
-                            if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
+                            if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                         }
@@ -2385,8 +2404,8 @@ fn aiur_fn_14(
                         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_14] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
-                        if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
+                        if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
@@ -2397,8 +2416,8 @@ fn aiur_fn_14(
                     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_14] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
-                    if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
+                    if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
@@ -2408,8 +2427,8 @@ fn aiur_fn_14(
                 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_14] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
-                if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_15] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
+                if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -2418,8 +2437,8 @@ fn aiur_fn_14(
             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_14] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-            if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_15] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+            if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -2427,23 +2446,23 @@ fn aiur_fn_14(
       _ => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_0 + __v_8);
-        let __ret: [G; OUT_14] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-        if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_15] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+        if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_15: usize = 8;
-const IN_15: usize = 8;
-const OUT_15: usize = 8;
-fn aiur_fn_15(
-  inp: [G; IN_15],
+const INPUT_SIZE_16: usize = 8;
+const IN_16: usize = 8;
+const OUT_16: usize = 8;
+fn aiur_fn_16(
+  inp: [G; IN_16],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_15], ExecError> {
+) -> Result<[G; OUT_16], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2477,8 +2496,8 @@ fn aiur_fn_15(
                                     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_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-                                    if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+                                    if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -2491,8 +2510,8 @@ fn aiur_fn_15(
                                     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_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
-                                    if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
+                                    if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                 }
@@ -2506,8 +2525,8 @@ fn aiur_fn_15(
                                 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_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
-                                if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
+                                if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -2520,8 +2539,8 @@ fn aiur_fn_15(
                             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_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
-                            if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
+                            if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                         }
@@ -2533,8 +2552,8 @@ fn aiur_fn_15(
                         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_15] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
-                        if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
+                        if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
@@ -2545,8 +2564,8 @@ fn aiur_fn_15(
                     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_15] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
-                    if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
+                    if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
@@ -2556,8 +2575,8 @@ fn aiur_fn_15(
                 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_15] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
-                if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_16] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
+                if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -2566,8 +2585,8 @@ fn aiur_fn_15(
             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_15] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-            if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_16] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+            if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -2575,23 +2594,23 @@ fn aiur_fn_15(
       _ => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_0 - __v_8);
-        let __ret: [G; OUT_15] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-        if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_16] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+        if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_16: usize = 8;
-const IN_16: usize = 8;
-const OUT_16: usize = 1;
-fn aiur_fn_16(
-  inp: [G; IN_16],
+const INPUT_SIZE_17: usize = 8;
+const IN_17: usize = 8;
+const OUT_17: usize = 1;
+fn aiur_fn_17(
+  inp: [G; IN_17],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_16], 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];
@@ -2623,21 +2642,21 @@ fn aiur_fn_16(
     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_16] = [__v_26];
-    if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_17] = [__v_26];
+    if let Some(result) = record.function_queries[17].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_17: usize = 4;
-const IN_17: usize = 4;
-const OUT_17: usize = 1;
-fn aiur_fn_17(
-  inp: [G; IN_17],
+const INPUT_SIZE_18: usize = 4;
+const IN_18: usize = 4;
+const OUT_18: usize = 1;
+fn aiur_fn_18(
+  inp: [G; IN_18],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_17], 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];
@@ -2652,21 +2671,21 @@ fn aiur_fn_17(
     let __v_10: G = (__v_7 + __v_9);
     let __v_11: G = (__v_5 + __v_10);
     let __v_12: G = (__v_0 + __v_11);
-    let __ret: [G; OUT_17] = [__v_12];
-    if let Some(result) = record.function_queries[17].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_18] = [__v_12];
+    if let Some(result) = record.function_queries[18].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_18: usize = 32;
-const IN_18: usize = 32;
-const OUT_18: usize = 8;
-fn aiur_fn_18(
-  inp: [G; IN_18],
+const INPUT_SIZE_19: usize = 32;
+const IN_19: usize = 32;
+const OUT_19: usize = 8;
+fn aiur_fn_19(
+  inp: [G; IN_19],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_18], 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];
@@ -2772,21 +2791,21 @@ fn aiur_fn_18(
     let __v_101: G = (__v_98 + __v_100);
     let __v_102: G = (__v_96 + __v_101);
     let __v_103: G = (__v_28 + __v_102);
-    let __ret: [G; OUT_18] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103];
-    if let Some(result) = record.function_queries[18].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_19] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103];
+    if let Some(result) = record.function_queries[19].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[19].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 = 32;
-fn aiur_fn_19(
-  inp: [G; IN_19],
+const INPUT_SIZE_20: usize = 1;
+const IN_20: usize = 1;
+const OUT_20: usize = 32;
+fn aiur_fn_20(
+  inp: [G; IN_20],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_19], ExecError> {
+) -> Result<[G; OUT_20], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(103);
@@ -2839,9 +2858,9 @@ fn aiur_fn_19(
     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_24] = { let __args: [G; IN_24] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { 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_25] = { let __args: [G; IN_25] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_51: G = __r_arr[0];
-    let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_24] = { let __args: [G; IN_24] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
     let __v_52: G = __r_arr[0];
     let __v_53: G = __r_arr[1];
     let __v_54: G = __r_arr[2];
@@ -2874,21 +2893,21 @@ fn aiur_fn_19(
     let __v_81: G = __r_arr[29];
     let __v_82: G = __r_arr[30];
     let __v_83: G = __r_arr[31];
-    let __ret: [G; OUT_19] = [__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];
-    if let Some(result) = record.function_queries[19].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_20] = [__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];
+    if let Some(result) = record.function_queries[20].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_20: usize = 33;
-const IN_20: usize = 33;
-const OUT_20: usize = 0;
-fn aiur_fn_20(
-  inp: [G; IN_20],
+const INPUT_SIZE_21: usize = 33;
+const IN_21: usize = 33;
+const OUT_21: usize = 0;
+fn aiur_fn_21(
+  inp: [G; IN_21],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_20], 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];
@@ -2973,9 +2992,9 @@ fn aiur_fn_20(
     let __v_80: G = G::from_u64(1);
     let __v_81: G = G::from_u64(1);
     let __v_82: G = { let __values: [G; 34] = [__v_80, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81]; 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_24] = { let __args: [G; IN_24] = [__v_0, __v_67, __v_68, __v_69, __v_78, __v_79, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { 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_25] = { let __args: [G; IN_25] = [__v_0, __v_67, __v_68, __v_69, __v_78, __v_79, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_83: G = __r_arr[0];
-    let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_24] = { let __args: [G; IN_24] = [__v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
     let __v_84: G = __r_arr[0];
     let __v_85: G = __r_arr[1];
     let __v_86: G = __r_arr[2];
@@ -3104,21 +3123,21 @@ fn aiur_fn_20(
     if (__v_115 != __v_32) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_115.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
-    let __ret: [G; OUT_20] = [];
-    if let Some(result) = record.function_queries[20].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_21] = [];
+    if let Some(result) = record.function_queries[21].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_21: usize = 1;
-const IN_21: usize = 1;
-const OUT_21: usize = 1;
-fn aiur_fn_21(
-  inp: [G; IN_21],
+const INPUT_SIZE_22: usize = 1;
+const IN_22: usize = 1;
+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_21], ExecError> {
+) -> Result<[G; OUT_22], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(103);
@@ -3171,9 +3190,9 @@ fn aiur_fn_21(
     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_24] = { let __args: [G; IN_24] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { 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_25] = { let __args: [G; IN_25] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_51: G = __r_arr[0];
-    let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_24] = { let __args: [G; IN_24] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
     let __v_52: G = __r_arr[0];
     let __v_53: G = __r_arr[1];
     let __v_54: G = __r_arr[2];
@@ -3207,21 +3226,21 @@ fn aiur_fn_21(
     let __v_82: G = __r_arr[30];
     let __v_83: G = __r_arr[31];
     let __v_84: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_21] = [__v_84];
-    if let Some(result) = record.function_queries[21].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_22] = [__v_84];
+    if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_22: usize = 34;
-const IN_22: usize = 34;
-const OUT_22: usize = 34;
-fn aiur_fn_22(
-  inp: [G; IN_22],
+const INPUT_SIZE_23: usize = 34;
+const IN_23: usize = 34;
+const OUT_23: usize = 34;
+fn aiur_fn_23(
+  inp: [G; IN_23],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_22], 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];
@@ -3295,13 +3314,13 @@ fn aiur_fn_22(
     match __v_34.as_canonical_u64() {
       1u64 => {
         let __v_68: G = G::from_u64(1);
-        let __ret: [G; OUT_22] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0];
-        if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_23] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0];
+        if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         let __v_68: G = G::from_u64(0);
-        let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_23] = { let __args: [G; IN_23] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_69: G = __r_arr[0];
         let __v_70: G = __r_arr[1];
         let __v_71: G = __r_arr[2];
@@ -3339,8 +3358,8 @@ fn aiur_fn_22(
         match __v_69.as_canonical_u64() {
           0u64 => {
             let __v_103: G = G::from_u64(1);
-            let __ret: [G; OUT_22] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102];
-            if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_23] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102];
+            if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
@@ -3449,7 +3468,7 @@ fn aiur_fn_22(
                 let __v_202: G = G::from_u64(0);
                 let __v_203: G = G::from_u64(0);
                 let __v_204: G = G::from_u64(0);
-                let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_204, __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, __v_136, __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_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__v_204, __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, __v_136, __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_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
                 let __v_205: G = __r_arr[0];
                 let __v_206: G = __r_arr[1];
                 let __v_207: G = __r_arr[2];
@@ -3486,8 +3505,8 @@ fn aiur_fn_22(
                 let __v_238: G = G::from_u64(0);
                 let __v_239: G = G::from_u64(0);
                 let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; 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_22] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240];
-                if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_23] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240];
+                if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -3523,7 +3542,7 @@ fn aiur_fn_22(
                 let __v_200: G = G::from_u64(0);
                 let __v_201: G = G::from_u64(0);
                 let __v_202: G = G::from_u64(0);
-                let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_202, __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, __v_136, __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_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__v_202, __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, __v_136, __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_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
                 let __v_203: G = __r_arr[0];
                 let __v_204: G = __r_arr[1];
                 let __v_205: G = __r_arr[2];
@@ -3560,8 +3579,8 @@ fn aiur_fn_22(
                 let __v_236: G = G::from_u64(0);
                 let __v_237: G = G::from_u64(0);
                 let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234]; 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_22] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238];
-                if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_23] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238];
+                if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -3578,15 +3597,15 @@ fn aiur_fn_22(
   })
 }
 
-const INPUT_SIZE_23: usize = 1;
-const IN_23: usize = 1;
-const OUT_23: usize = 32;
-fn aiur_fn_23(
-  inp: [G; IN_23],
+const INPUT_SIZE_24: usize = 1;
+const IN_24: usize = 1;
+const OUT_24: usize = 32;
+fn aiur_fn_24(
+  inp: [G; IN_24],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_23], ExecError> {
+) -> Result<[G; OUT_24], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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 };
@@ -3663,13 +3682,13 @@ fn aiur_fn_23(
         let __v_68: G = __loaded[33];
         match __v_35.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_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_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34];
-            if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_24] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34];
+            if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_69: G = G::from_u64(1);
-            let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_23] = { let __args: [G; IN_23] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_70: G = __r_arr[0];
             let __v_71: G = __r_arr[1];
             let __v_72: G = __r_arr[2];
@@ -3706,7 +3725,7 @@ fn aiur_fn_23(
             let __v_103: G = __r_arr[33];
             match __v_70.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_24] = { let __args: [G; IN_24] = [__v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
                 let __v_104: G = __r_arr[0];
                 let __v_105: G = __r_arr[1];
                 let __v_106: G = __r_arr[2];
@@ -3739,14 +3758,14 @@ fn aiur_fn_23(
                 let __v_133: G = __r_arr[29];
                 let __v_134: G = __r_arr[30];
                 let __v_135: G = __r_arr[31];
-                let __ret: [G; OUT_23] = [__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];
-                if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_24] = [__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];
+                if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_104: G = G::from_u64(0);
                 let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_24] = { let __args: [G; IN_24] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
                 let __v_106: G = __r_arr[0];
                 let __v_107: G = __r_arr[1];
                 let __v_108: G = __r_arr[2];
@@ -3779,8 +3798,8 @@ fn aiur_fn_23(
                 let __v_135: G = __r_arr[29];
                 let __v_136: G = __r_arr[30];
                 let __v_137: G = __r_arr[31];
-                let __ret: [G; OUT_23] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137];
-                if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_24] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137];
+                if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -3797,15 +3816,15 @@ fn aiur_fn_23(
   })
 }
 
-const INPUT_SIZE_24: usize = 7;
-const IN_24: usize = 7;
-const OUT_24: usize = 1;
-fn aiur_fn_24(
-  inp: [G; IN_24],
+const INPUT_SIZE_25: usize = 7;
+const IN_25: usize = 7;
+const OUT_25: usize = 1;
+fn aiur_fn_25(
+  inp: [G; IN_25],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_24], ExecError> {
+) -> 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];
@@ -3820,10 +3839,10 @@ fn aiur_fn_24(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
-        let __ret: [G; OUT_24] = [__v_10];
-        if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_25] = [__v_10];
+        if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -3831,10 +3850,10 @@ fn aiur_fn_24(
         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_28] = { let __args: [G; IN_28] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_29(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_24] = [__v_12];
-            if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_25] = [__v_12];
+            if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -3842,10 +3861,10 @@ fn aiur_fn_24(
             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_24] = { let __args: [G; IN_24] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { 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_25] = { let __args: [G; IN_25] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
-            let __ret: [G; OUT_24] = [__v_16];
-            if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_25] = [__v_16];
+            if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -3857,15 +3876,15 @@ fn aiur_fn_24(
   })
 }
 
-const INPUT_SIZE_25: usize = 1;
-const IN_25: usize = 1;
-const OUT_25: usize = 64;
-fn aiur_fn_25(
-  inp: [G; IN_25],
+const INPUT_SIZE_26: usize = 1;
+const IN_26: usize = 1;
+const OUT_26: usize = 64;
+fn aiur_fn_26(
+  inp: [G; IN_26],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_25], ExecError> {
+) -> Result<[G; OUT_26], 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 };
@@ -4252,8 +4271,8 @@ fn aiur_fn_25(
                                                                                                                                                                                                                                                                 let __v_192: G = __loaded[2];
                                                                                                                                                                                                                                                                 match __v_190.as_canonical_u64() {
                                                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                                                    let __ret: [G; OUT_25] = [__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];
-                                                                                                                                                                                                                                                                    if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                                                                                                                                                                                                                                    let __ret: [G; OUT_26] = [__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];
+                                                                                                                                                                                                                                                                    if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                                                                                                                                                                                                                                     return Ok(__ret);
                                                                                                                                                                                                                                                                   },
                                                                                                                                                                                                                                                                   _ => {
@@ -4578,22 +4597,22 @@ fn aiur_fn_25(
   })
 }
 
-const INPUT_SIZE_26: usize = 2;
-const IN_26: usize = 2;
-const OUT_26: usize = 1;
-fn aiur_fn_26(
-  inp: [G; IN_26],
+const INPUT_SIZE_27: usize = 2;
+const IN_27: usize = 2;
+const OUT_27: usize = 1;
+fn aiur_fn_27(
+  inp: [G; IN_27],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_26], ExecError> {
+) -> 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_26] = [__v_0];
-        if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_27] = [__v_0];
+        if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -4602,25 +4621,25 @@ fn aiur_fn_26(
         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_26] = { let __args: [G; IN_26] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_26] = [__v_7];
-        if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_27] = [__v_7];
+        if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_27: usize = 6;
-const IN_27: usize = 6;
-const OUT_27: usize = 1;
-fn aiur_fn_27(
-  inp: [G; IN_27],
+const INPUT_SIZE_28: usize = 6;
+const IN_28: usize = 6;
+const OUT_28: usize = 1;
+fn aiur_fn_28(
+  inp: [G; IN_28],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_27], ExecError> {
+) -> 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];
@@ -4793,7 +4812,7 @@ fn aiur_fn_27(
                                             let __v_145: G = G::from_u64(0);
                                             let __v_146: G = G::from_u64(0);
                                             let __v_147: G = G::from_u64(0);
-                                            let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_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_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_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_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
                                             let __v_148: G = __r_arr[0];
                                             let __v_149: G = __r_arr[1];
                                             let __v_150: G = __r_arr[2];
@@ -4827,62 +4846,62 @@ fn aiur_fn_27(
                                             let __v_178: G = __r_arr[30];
                                             let __v_179: G = __r_arr[31];
                                             let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __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]; 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_27] = [__v_180];
-                                            if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            let __ret: [G; OUT_28] = [__v_180];
+                                            if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __ret: [G; OUT_27] = [__v_5];
-                                            if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            let __ret: [G; OUT_28] = [__v_5];
+                                            if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                             return Ok(__ret);
                                           },
                                         }
                                       },
                                       _ => {
-                                        let __ret: [G; OUT_27] = [__v_5];
-                                        if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        let __ret: [G; OUT_28] = [__v_5];
+                                        if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                         return Ok(__ret);
                                       },
                                     }
                                   },
                                   _ => {
-                                    let __ret: [G; OUT_27] = [__v_5];
-                                    if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_28] = [__v_5];
+                                    if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
-                                let __ret: [G; OUT_27] = [__v_5];
-                                if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_28] = [__v_5];
+                                if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
-                            let __ret: [G; OUT_27] = [__v_5];
-                            if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_28] = [__v_5];
+                            if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
-                        let __ret: [G; OUT_27] = [__v_5];
-                        if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_28] = [__v_5];
+                        if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __ret: [G; OUT_27] = [__v_5];
-                    if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_28] = [__v_5];
+                    if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_27] = [__v_5];
-                if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_28] = [__v_5];
+                if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -4923,8 +4942,8 @@ fn aiur_fn_27(
             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_27] = [__v_42];
-            if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_28] = [__v_42];
+            if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -4939,7 +4958,7 @@ fn aiur_fn_27(
         let __v_14: G = __loaded[5];
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_17: G = __r_arr[0];
         let __v_18: G = (__v_17 * __v_8);
         let __v_19: G = (__v_2 - __v_1);
@@ -4949,9 +4968,9 @@ fn aiur_fn_27(
         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_26] = { let __args: [G; IN_26] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { 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_26] = { let __args: [G; IN_26] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
         let __v_28: G = __r_arr[1];
         let __v_29: G = __r_arr[2];
@@ -5082,7 +5101,7 @@ fn aiur_fn_27(
         let __v_152: G = G::from_u64(0);
         let __v_153: G = G::from_u64(0);
         let __v_154: G = G::from_u64(0);
-        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_154, __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_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_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__v_154, __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_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_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
         let __v_155: G = __r_arr[0];
         let __v_156: G = __r_arr[1];
         let __v_157: G = __r_arr[2];
@@ -5116,23 +5135,23 @@ fn aiur_fn_27(
         let __v_185: G = __r_arr[30];
         let __v_186: G = __r_arr[31];
         let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __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]; 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_27] = [__v_187];
-        if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_28] = [__v_187];
+        if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_28: usize = 6;
-const IN_28: usize = 6;
-const OUT_28: usize = 1;
-fn aiur_fn_28(
-  inp: [G; IN_28],
+const INPUT_SIZE_29: usize = 6;
+const IN_29: usize = 6;
+const OUT_29: usize = 1;
+fn aiur_fn_29(
+  inp: [G; IN_29],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_28], ExecError> {
+) -> 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];
@@ -5143,7 +5162,7 @@ fn aiur_fn_28(
     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_25] = { let __args: [G; IN_25] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { 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_26] = { let __args: [G; IN_26] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
     let __v_11: G = __r_arr[2];
@@ -5221,7 +5240,7 @@ fn aiur_fn_28(
         let __v_79: G = __loaded[5];
         let __v_80: G = __loaded[6];
         let __v_81: G = __loaded[7];
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_82: G = __r_arr[0];
         let __v_83: G = (__v_73 * __v_82);
         let __v_84: G = (__v_8 * __v_83);
@@ -5325,7 +5344,7 @@ fn aiur_fn_28(
         let __v_180: G = G::from_u64(0);
         let __v_181: G = G::from_u64(0);
         let __v_182: G = G::from_u64(0);
-        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_182, __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, __v_146, __v_147, __v_148, __v_149, __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_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__v_182, __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, __v_146, __v_147, __v_148, __v_149, __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_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
         let __v_183: G = __r_arr[0];
         let __v_184: G = __r_arr[1];
         let __v_185: G = __r_arr[2];
@@ -5373,7 +5392,7 @@ fn aiur_fn_28(
         let __v_226: G = __loaded[5];
         let __v_227: G = __loaded[6];
         let __v_228: G = __loaded[7];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { 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_15] = { let __args: [G; IN_15] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_229: G = __r_arr[0];
         let __v_230: G = __r_arr[1];
         let __v_231: G = __r_arr[2];
@@ -5384,10 +5403,10 @@ fn aiur_fn_28(
         let __v_236: G = __r_arr[7];
         let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; 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_238: 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_24] = { let __args: [G; IN_24] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { 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_25] = { let __args: [G; IN_25] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
         let __v_239: G = __r_arr[0];
-        let __ret: [G; OUT_28] = [__v_239];
-        if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_29] = [__v_239];
+        if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -5405,7 +5424,7 @@ fn aiur_fn_28(
         let __v_81: G = __loaded[5];
         let __v_82: G = __loaded[6];
         let __v_83: G = __loaded[7];
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_84: G = __r_arr[0];
         let __v_85: G = (__v_84 * __v_8);
         let __v_86: G = (__v_75 * __v_85);
@@ -5481,7 +5500,7 @@ fn aiur_fn_28(
         let __v_154: G = G::from_u64(0);
         let __v_155: G = G::from_u64(0);
         let __v_156: G = G::from_u64(0);
-        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_156, __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_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_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__v_156, __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_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_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
         let __v_157: G = __r_arr[0];
         let __v_158: G = __r_arr[1];
         let __v_159: G = __r_arr[2];
@@ -5521,25 +5540,25 @@ fn aiur_fn_28(
         let __v_193: G = G::from_u64(1);
         let __v_194: G = (__v_2 + __v_193);
         let __v_195: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { 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_25] = { let __args: [G; IN_25] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
         let __v_196: G = __r_arr[0];
-        let __ret: [G; OUT_28] = [__v_196];
-        if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_29] = [__v_196];
+        if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_29: usize = 24;
-const IN_29: usize = 24;
-const OUT_29: usize = 16;
-fn aiur_fn_29(
-  inp: [G; IN_29],
+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_29], ExecError> {
+) -> 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];
@@ -5669,21 +5688,21 @@ fn aiur_fn_29(
     let __v_89: G = (__v_82 + __v_85);
     let __v_90: G = (__v_84 + __v_87);
     let __v_91: G = (__v_86 + __v_81);
-    let __ret: [G; OUT_29] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70];
-    if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_30] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70];
+    if let Some(result) = record.function_queries[30].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_30: usize = 128;
-const IN_30: usize = 128;
-const OUT_30: usize = 128;
-fn aiur_fn_30(
-  inp: [G; IN_30],
+const INPUT_SIZE_31: usize = 128;
+const IN_31: usize = 128;
+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_30], 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];
@@ -6645,21 +6664,21 @@ fn aiur_fn_30(
     let __v_669: G = (__v_662 + __v_665);
     let __v_670: G = (__v_664 + __v_667);
     let __v_671: G = (__v_666 + __v_661);
-    let __ret: [G; OUT_30] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __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];
-    if let Some(result) = record.function_queries[30].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_31] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __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];
+    if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_31: usize = 106;
-const IN_31: usize = 106;
-const OUT_31: usize = 32;
-fn aiur_fn_31(
-  inp: [G; IN_31],
+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_31], 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];
@@ -6790,7 +6809,7 @@ fn aiur_fn_31(
     let __v_126: G = G::from_u64(0);
     let __v_127: G = G::from_u64(0);
     let __v_128: G = G::from_u64(0);
-    let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
     let __v_129: G = __r_arr[0];
     let __v_130: G = __r_arr[1];
     let __v_131: G = __r_arr[2];
@@ -6823,21 +6842,21 @@ fn aiur_fn_31(
     let __v_158: G = __r_arr[29];
     let __v_159: G = __r_arr[30];
     let __v_160: G = __r_arr[31];
-    let __ret: [G; OUT_31] = [__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];
-    if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_32] = [__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];
+    if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_32: usize = 129;
-const IN_32: usize = 129;
-const OUT_32: usize = 32;
-fn aiur_fn_32(
-  inp: [G; IN_32],
+const INPUT_SIZE_33: usize = 129;
+const IN_33: usize = 129;
+const OUT_33: usize = 32;
+fn aiur_fn_33(
+  inp: [G; IN_33],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_32], ExecError> {
+) -> Result<[G; OUT_33], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7002,8 +7021,8 @@ fn aiur_fn_32(
         let __v_158: G = if unconstrained { Bytes2::xor(&__v_30, &__v_62) } else { bytes2_xor_value(__v_30, __v_62, record) };
         let __v_159: G = if unconstrained { Bytes2::xor(&__v_31, &__v_63) } else { bytes2_xor_value(__v_31, __v_63, record) };
         let __v_160: G = if unconstrained { Bytes2::xor(&__v_32, &__v_64) } else { bytes2_xor_value(__v_32, __v_64, record) };
-        let __ret: [G; OUT_32] = [__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];
-        if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_33] = [__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];
+        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -7841,7 +7860,7 @@ fn aiur_fn_32(
         let __v_672: G = (__v_667 + __v_662);
         let __v_673: G = G::from_u64(1);
         let __v_674: G = (__v_0 + __v_673);
-        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
         let __v_675: G = __r_arr[0];
         let __v_676: G = __r_arr[1];
         let __v_677: G = __r_arr[2];
@@ -7874,23 +7893,23 @@ fn aiur_fn_32(
         let __v_704: G = __r_arr[29];
         let __v_705: G = __r_arr[30];
         let __v_706: G = __r_arr[31];
-        let __ret: [G; OUT_32] = [__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_704, __v_705, __v_706];
-        if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_33] = [__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_704, __v_705, __v_706];
+        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_33: usize = 19;
-const IN_33: usize = 19;
-const OUT_33: usize = 1;
-fn aiur_fn_33(
-  inp: [G; IN_33],
+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_33], 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];
@@ -7914,18 +7933,18 @@ fn aiur_fn_33(
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_33] = [__v_20];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_20];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { 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_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_33] = [__v_20];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_20];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
@@ -7939,14 +7958,14 @@ fn aiur_fn_33(
         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_38] = { let __args: [G; IN_38] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_33] = [__v_30];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_30];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
@@ -7960,14 +7979,14 @@ fn aiur_fn_33(
         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_38] = { let __args: [G; IN_38] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_33] = [__v_30];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_30];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
@@ -7991,34 +8010,34 @@ fn aiur_fn_33(
         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_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_33] = [__v_40];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_40];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { 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_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_33] = [__v_20];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_20];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { 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_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_33] = [__v_20];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_20];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       7u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { 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];
@@ -8028,16 +8047,16 @@ fn aiur_fn_33(
         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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_33] = [__v_29];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_29];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       8u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { 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_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { 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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -8047,16 +8066,16 @@ fn aiur_fn_33(
         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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { 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_46] = { let __args: [G; IN_46] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_33] = [__v_29];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_29];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       9u64 => {
-        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]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { 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_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { 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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -8066,12 +8085,12 @@ fn aiur_fn_33(
         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_46] = { let __args: [G; IN_46] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { 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_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_33] = [__v_29];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_29];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       10u64 => {
@@ -8133,24 +8152,24 @@ fn aiur_fn_33(
         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_33] = { let __args: [G; IN_33] = [__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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__v_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_33] = [__v_77];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_77];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { 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_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_33] = [__v_20];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_20];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -8160,15 +8179,15 @@ fn aiur_fn_33(
   })
 }
 
-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_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_34], 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];
@@ -8182,8 +8201,8 @@ fn aiur_fn_34(
     let __v_9: G = inp[9];
     match __v_8.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_34] = [__v_9];
-        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_35] = [__v_9];
+        if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -8191,26 +8210,26 @@ fn aiur_fn_34(
         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_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_34] = [__v_15];
-        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_35] = [__v_15];
+        if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_35: usize = 9;
-const IN_35: usize = 9;
-const OUT_35: usize = 1;
-fn aiur_fn_35(
-  inp: [G; IN_35],
+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_35], 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];
@@ -8221,7 +8240,7 @@ fn aiur_fn_35(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__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[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     let __v_10: G = G::from_u64(128);
     let __v_11: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_10) } else { bytes2_less_than_value(__v_0, __v_10, record) };
@@ -8231,8 +8250,8 @@ fn aiur_fn_35(
           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_35] = [__v_13];
-            if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_36] = [__v_13];
+            if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -8241,11 +8260,11 @@ fn aiur_fn_35(
             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_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_35] = [__v_18];
-            if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_36] = [__v_18];
+            if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -8256,26 +8275,26 @@ fn aiur_fn_35(
         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_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_35] = [__v_18];
-        if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_36] = [__v_18];
+        if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_36: usize = 10;
-const IN_36: usize = 10;
-const OUT_36: usize = 1;
-fn aiur_fn_36(
-  inp: [G; IN_36],
+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_36], 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];
@@ -8287,7 +8306,7 @@ fn aiur_fn_36(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__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[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
     let __v_11: G = G::from_u64(32);
     let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) };
@@ -8300,8 +8319,8 @@ fn aiur_fn_36(
             let __v_15: G = (__v_14 + __v_1);
             let __v_16: G = G::from_u64(0);
             let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_36] = [__v_17];
-            if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_37] = [__v_17];
+            if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -8313,11 +8332,11 @@ fn aiur_fn_36(
             let __v_18: G = (__v_15 + __v_17);
             let __v_19: G = (__v_14 + __v_18);
             let __v_20: G = G::from_u64(0);
-            let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_36] = [__v_22];
-            if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_37] = [__v_22];
+            if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -8331,26 +8350,26 @@ fn aiur_fn_36(
         let __v_18: G = (__v_15 + __v_17);
         let __v_19: G = (__v_14 + __v_18);
         let __v_20: G = G::from_u64(0);
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_36] = [__v_22];
-        if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_37] = [__v_22];
+        if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_37: usize = 10;
-const IN_37: usize = 10;
-const OUT_37: usize = 1;
-fn aiur_fn_37(
-  inp: [G; IN_37],
+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_37], 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];
@@ -8362,7 +8381,7 @@ fn aiur_fn_37(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__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[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
     let __v_11: G = G::from_u64(8);
     let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) };
@@ -8375,8 +8394,8 @@ fn aiur_fn_37(
             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_37] = [__v_17];
-            if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_38] = [__v_17];
+            if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -8388,11 +8407,11 @@ fn aiur_fn_37(
             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_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_37] = [__v_22];
-            if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_38] = [__v_22];
+            if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -8406,26 +8425,26 @@ fn aiur_fn_37(
         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_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_37] = [__v_22];
-        if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_38] = [__v_22];
+        if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_38: usize = 2;
-const IN_38: usize = 2;
-const OUT_38: usize = 1;
-fn aiur_fn_38(
-  inp: [G; IN_38],
+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_38], 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];
@@ -8442,17 +8461,17 @@ fn aiur_fn_38(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_38] = [__v_1];
-        if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_39] = [__v_1];
+        if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_38] = [__v_13];
-        if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_39] = [__v_13];
+        if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -8462,15 +8481,15 @@ fn aiur_fn_38(
   })
 }
 
-const INPUT_SIZE_39: usize = 2;
-const IN_39: usize = 2;
-const OUT_39: usize = 1;
-fn aiur_fn_39(
-  inp: [G; IN_39],
+const INPUT_SIZE_40: usize = 2;
+const IN_40: usize = 2;
+const OUT_40: usize = 1;
+fn aiur_fn_40(
+  inp: [G; IN_40],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_39], 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];
@@ -8479,32 +8498,32 @@ fn aiur_fn_39(
         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_39] = [__v_4];
-        if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_40] = [__v_4];
+        if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].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_39] = [__v_4];
-        if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_40] = [__v_4];
+        if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].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_39] = [__v_4];
-        if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_40] = [__v_4];
+        if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].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_39] = [__v_4];
-        if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_40] = [__v_4];
+        if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -8514,15 +8533,15 @@ fn aiur_fn_39(
   })
 }
 
-const INPUT_SIZE_40: usize = 3;
-const IN_40: usize = 3;
-const OUT_40: usize = 1;
-fn aiur_fn_40(
-  inp: [G; IN_40],
+const INPUT_SIZE_41: usize = 3;
+const IN_41: usize = 3;
+const OUT_41: usize = 1;
+fn aiur_fn_41(
+  inp: [G; IN_41],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_40], 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];
@@ -8534,16 +8553,16 @@ fn aiur_fn_40(
             let __v_3: G = G::from_u64(0);
             let __v_4: G = G::from_u64(0);
             let __v_5: G = { let __values: [G; 3] = [__v_3, __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 __ret: [G; OUT_40] = [__v_5];
-            if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_41] = [__v_5];
+            if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
             let __v_3: G = G::from_u64(0);
             let __v_4: G = G::from_u64(4);
             let __v_5: G = { let __values: [G; 3] = [__v_3, __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 __ret: [G; OUT_40] = [__v_5];
-            if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_41] = [__v_5];
+            if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -8557,16 +8576,16 @@ fn aiur_fn_40(
             let __v_3: G = G::from_u64(0);
             let __v_4: G = G::from_u64(1);
             let __v_5: G = { let __values: [G; 3] = [__v_3, __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 __ret: [G; OUT_40] = [__v_5];
-            if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_41] = [__v_5];
+            if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
             let __v_3: G = G::from_u64(0);
             let __v_4: G = G::from_u64(5);
             let __v_5: G = { let __values: [G; 3] = [__v_3, __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 __ret: [G; OUT_40] = [__v_5];
-            if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_41] = [__v_5];
+            if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -8580,16 +8599,16 @@ fn aiur_fn_40(
             let __v_3: G = G::from_u64(0);
             let __v_4: G = G::from_u64(2);
             let __v_5: G = { let __values: [G; 3] = [__v_3, __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 __ret: [G; OUT_40] = [__v_5];
-            if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_41] = [__v_5];
+            if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
             let __v_3: G = G::from_u64(0);
             let __v_4: G = G::from_u64(6);
             let __v_5: G = { let __values: [G; 3] = [__v_3, __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 __ret: [G; OUT_40] = [__v_5];
-            if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_41] = [__v_5];
+            if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -8603,16 +8622,16 @@ fn aiur_fn_40(
             let __v_3: G = G::from_u64(0);
             let __v_4: G = G::from_u64(3);
             let __v_5: G = { let __values: [G; 3] = [__v_3, __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 __ret: [G; OUT_40] = [__v_5];
-            if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_41] = [__v_5];
+            if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
             let __v_3: G = G::from_u64(0);
             let __v_4: G = G::from_u64(7);
             let __v_5: G = { let __values: [G; 3] = [__v_3, __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 __ret: [G; OUT_40] = [__v_5];
-            if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_41] = [__v_5];
+            if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -8627,15 +8646,15 @@ fn aiur_fn_40(
   })
 }
 
-const INPUT_SIZE_41: usize = 18;
-const IN_41: usize = 18;
-const OUT_41: usize = 8;
-fn aiur_fn_41(
-  inp: [G; IN_41],
+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_41], 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];
@@ -8676,7 +8695,7 @@ fn aiur_fn_41(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { 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];
@@ -8685,7 +8704,7 @@ fn aiur_fn_41(
         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_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { 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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -8694,8 +8713,8 @@ fn aiur_fn_41(
         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_41] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].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];
+        if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -8707,23 +8726,23 @@ fn aiur_fn_41(
         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_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].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];
+        if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_42: usize = 18;
-const IN_42: usize = 18;
-const OUT_42: usize = 8;
-fn aiur_fn_42(
-  inp: [G; IN_42],
+const INPUT_SIZE_43: usize = 18;
+const IN_43: usize = 18;
+const OUT_43: usize = 8;
+fn aiur_fn_43(
+  inp: [G; IN_43],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_42], 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];
@@ -8764,7 +8783,7 @@ fn aiur_fn_42(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { 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_43] = { let __args: [G; IN_43] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { 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_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = __r_arr[2];
@@ -8773,7 +8792,7 @@ fn aiur_fn_42(
         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_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { 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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -8782,8 +8801,8 @@ fn aiur_fn_42(
         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_42] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_43] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
+        if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -8795,23 +8814,23 @@ fn aiur_fn_42(
         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_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_43] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_43: usize = 18;
-const IN_43: usize = 18;
-const OUT_43: usize = 8;
-fn aiur_fn_43(
-  inp: [G; IN_43],
+const INPUT_SIZE_44: usize = 18;
+const IN_44: usize = 18;
+const OUT_44: usize = 8;
+fn aiur_fn_44(
+  inp: [G; IN_44],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_43], 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];
@@ -8852,7 +8871,7 @@ fn aiur_fn_43(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { 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_44] = { let __args: [G; IN_44] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { 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_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = __r_arr[2];
@@ -8861,7 +8880,7 @@ fn aiur_fn_43(
         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_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { 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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -8870,8 +8889,8 @@ fn aiur_fn_43(
         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_43] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_44] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
+        if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -8883,23 +8902,23 @@ fn aiur_fn_43(
         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_43] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_44] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_44: usize = 19;
-const IN_44: usize = 19;
-const OUT_44: usize = 1;
-fn aiur_fn_44(
-  inp: [G; IN_44],
+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_44], 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];
@@ -8960,34 +8979,34 @@ fn aiur_fn_44(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_44] = { let __args: [G; IN_44] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { 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_45] = { let __args: [G; IN_45] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { 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_56: G = __r_arr[0];
-        let __ret: [G; OUT_44] = [__v_56];
-        if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_45] = [__v_56];
+        if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        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_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_44] = [__v_19];
-        if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_45] = [__v_19];
+        if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_45: usize = 19;
-const IN_45: usize = 19;
-const OUT_45: usize = 1;
-fn aiur_fn_45(
-  inp: [G; IN_45],
+const INPUT_SIZE_46: usize = 19;
+const IN_46: usize = 19;
+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_45], 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];
@@ -9048,36 +9067,36 @@ fn aiur_fn_45(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { 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_46] = { let __args: [G; IN_46] = [__v_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[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { 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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_1, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { 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_40] = { let __args: [G; IN_40] = [__v_1, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { 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_57: G = __r_arr[0];
-        let __ret: [G; OUT_45] = [__v_57];
-        if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_46] = [__v_57];
+        if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        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_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_45] = [__v_19];
-        if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_46] = [__v_19];
+        if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_46: usize = 19;
-const IN_46: usize = 19;
-const OUT_46: usize = 1;
-fn aiur_fn_46(
-  inp: [G; IN_46],
+const INPUT_SIZE_47: usize = 19;
+const IN_47: usize = 19;
+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_46], 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];
@@ -9138,36 +9157,36 @@ fn aiur_fn_46(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_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[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { 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_47] = { let __args: [G; IN_47] = [__v_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[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { 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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_1, __v_2, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { 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_41] = { let __args: [G; IN_41] = [__v_1, __v_2, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { 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_57: G = __r_arr[0];
-        let __ret: [G; OUT_46] = [__v_57];
-        if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_47] = [__v_57];
+        if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        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_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_46] = [__v_19];
-        if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_47] = [__v_19];
+        if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_47: usize = 2;
-const IN_47: usize = 2;
-const OUT_47: usize = 1;
-fn aiur_fn_47(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_47], 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];
@@ -9268,21 +9287,21 @@ fn aiur_fn_47(
     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_47] = [__v_97];
-    if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_48] = [__v_97];
+    if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-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_49: usize = 2;
+const IN_49: usize = 2;
+const OUT_49: usize = 1;
+fn aiur_fn_49(
+  inp: [G; IN_49],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_48], 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];
@@ -9291,20 +9310,20 @@ fn aiur_fn_48(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(0);
-            let __ret: [G; OUT_48] = [__v_2];
-            if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_49] = [__v_2];
+            if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(1);
-            let __ret: [G; OUT_48] = [__v_2];
-            if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_49] = [__v_2];
+            if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(2);
-            let __ret: [G; OUT_48] = [__v_2];
-            if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_49] = [__v_2];
+            if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -9316,20 +9335,20 @@ fn aiur_fn_48(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(4);
-            let __ret: [G; OUT_48] = [__v_2];
-            if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_49] = [__v_2];
+            if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(5);
-            let __ret: [G; OUT_48] = [__v_2];
-            if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_49] = [__v_2];
+            if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(6);
-            let __ret: [G; OUT_48] = [__v_2];
-            if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_49] = [__v_2];
+            if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -9341,20 +9360,20 @@ fn aiur_fn_48(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(8);
-            let __ret: [G; OUT_48] = [__v_2];
-            if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_49] = [__v_2];
+            if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(9);
-            let __ret: [G; OUT_48] = [__v_2];
-            if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_49] = [__v_2];
+            if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(10);
-            let __ret: [G; OUT_48] = [__v_2];
-            if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_49] = [__v_2];
+            if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -9369,15 +9388,15 @@ fn aiur_fn_48(
   })
 }
 
-const INPUT_SIZE_49: usize = 9;
-const IN_49: usize = 9;
-const OUT_49: usize = 8;
-fn aiur_fn_49(
-  inp: [G; IN_49],
+const INPUT_SIZE_50: usize = 9;
+const IN_50: usize = 9;
+const OUT_50: usize = 8;
+fn aiur_fn_50(
+  inp: [G; IN_50],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_49], 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];
@@ -9400,7 +9419,7 @@ fn aiur_fn_49(
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
         let __v_17: G = __loaded[8];
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { 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_50] = { let __args: [G; IN_50] = [__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[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { 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_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -9409,7 +9428,7 @@ fn aiur_fn_49(
         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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { 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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
         let __v_27: G = __r_arr[1];
         let __v_28: G = __r_arr[2];
@@ -9418,8 +9437,8 @@ fn aiur_fn_49(
         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_49] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-        if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_50] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
+        if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -9431,23 +9450,23 @@ fn aiur_fn_49(
         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_49] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16];
-        if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_50] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16];
+        if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_50: usize = 9;
-const IN_50: usize = 9;
-const OUT_50: usize = 9;
-fn aiur_fn_50(
-  inp: [G; IN_50],
+const INPUT_SIZE_51: usize = 9;
+const IN_51: usize = 9;
+const OUT_51: usize = 9;
+fn aiur_fn_51(
+  inp: [G; IN_51],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_50], 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];
@@ -9470,7 +9489,7 @@ fn aiur_fn_50(
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
         let __v_17: G = __loaded[8];
-        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__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[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { 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_51] = { let __args: [G; IN_51] = [__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[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { 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_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -9480,28 +9499,28 @@ fn aiur_fn_50(
         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_50] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-        if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_51] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
+        if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_50] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_51] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_51: usize = 10;
-const IN_51: usize = 10;
-const OUT_51: usize = 1;
-fn aiur_fn_51(
-  inp: [G; IN_51],
+const INPUT_SIZE_52: usize = 10;
+const IN_52: usize = 10;
+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_51], 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];
@@ -9518,12 +9537,12 @@ fn aiur_fn_51(
         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_51] = [__v_12];
-        if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_52] = [__v_12];
+        if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { 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_50] = { let __args: [G; IN_50] = [__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[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -9532,7 +9551,7 @@ fn aiur_fn_51(
         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_50] = { let __args: [G; IN_50] = [__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[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { 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_51] = { let __args: [G; IN_51] = [__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[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { 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_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -9543,12 +9562,12 @@ fn aiur_fn_51(
         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_51] = { let __args: [G; IN_51] = [__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[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { 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_52] = { let __args: [G; IN_52] = [__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[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_51] = [__v_29];
-        if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_52] = [__v_29];
+        if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
@@ -9581,14 +9600,14 @@ fn aiur_fn_51(
         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_51] = { let __args: [G; IN_51] = [__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[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { 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_52] = { let __args: [G; IN_52] = [__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[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { 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_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__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[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { 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_52] = { let __args: [G; IN_52] = [__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[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { 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_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_51] = [__v_39];
-        if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_52] = [__v_39];
+        if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
@@ -9621,22 +9640,22 @@ fn aiur_fn_51(
         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_51] = { let __args: [G; IN_51] = [__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[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { 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_52] = { let __args: [G; IN_52] = [__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[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { 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_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__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[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { 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_52] = { let __args: [G; IN_52] = [__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[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { 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_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_51] = [__v_39];
-        if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_52] = [__v_39];
+        if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
         let __v_10: G = G::from_u64(3);
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_51] = [__v_11];
-        if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_52] = [__v_11];
+        if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -9646,15 +9665,15 @@ fn aiur_fn_51(
   })
 }
 
-const INPUT_SIZE_52: usize = 2;
-const IN_52: usize = 2;
-const OUT_52: usize = 1;
-fn aiur_fn_52(
-  inp: [G; IN_52],
+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_52], 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];
@@ -9664,8 +9683,8 @@ fn aiur_fn_52(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_52] = [__v_1];
-        if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_53] = [__v_1];
+        if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -9688,12 +9707,12 @@ fn aiur_fn_52(
         let __v_20: G = __loaded[15];
         let __v_21: G = __loaded[16];
         let __v_22: G = __loaded[17];
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { 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_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_52] = [__v_24];
-        if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_53] = [__v_24];
+        if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -9703,15 +9722,15 @@ fn aiur_fn_52(
   })
 }
 
-const INPUT_SIZE_53: usize = 2;
-const IN_53: usize = 2;
-const OUT_53: usize = 1;
-fn aiur_fn_53(
-  inp: [G; IN_53],
+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_53], 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];
@@ -9721,8 +9740,8 @@ fn aiur_fn_53(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_53] = [__v_1];
-        if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_54] = [__v_1];
+        if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -9736,12 +9755,12 @@ fn aiur_fn_53(
         let __v_11: G = __loaded[6];
         let __v_12: G = __loaded[7];
         let __v_13: G = __loaded[8];
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { 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_54] = { let __args: [G; IN_54] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__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[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { 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_52] = { let __args: [G; IN_52] = [__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[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { 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_15: G = __r_arr[0];
-        let __ret: [G; OUT_53] = [__v_15];
-        if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_54] = [__v_15];
+        if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -9751,15 +9770,15 @@ fn aiur_fn_53(
   })
 }
 
-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_55: usize = 2;
+const IN_55: usize = 2;
+const OUT_55: usize = 1;
+fn aiur_fn_55(
+  inp: [G; IN_55],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_54], 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];
@@ -9769,17 +9788,17 @@ fn aiur_fn_54(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_54] = [__v_1];
-        if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_55] = [__v_1];
+        if let Some(result) = record.function_queries[55].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { 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_55] = { let __args: [G; IN_55] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { 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_48] = { let __args: [G; IN_48] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_54] = [__v_6];
-        if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_55] = [__v_6];
+        if let Some(result) = record.function_queries[55].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -9789,15 +9808,15 @@ fn aiur_fn_54(
   })
 }
 
-const INPUT_SIZE_55: usize = 13;
-const IN_55: usize = 13;
-const OUT_55: usize = 1;
-fn aiur_fn_55(
-  inp: [G; IN_55],
+const INPUT_SIZE_56: usize = 13;
+const IN_56: usize = 13;
+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_55], 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];
@@ -9852,33 +9871,33 @@ fn aiur_fn_55(
         let __v_46: G = __loaded[15];
         let __v_47: G = __loaded[16];
         let __v_48: G = __loaded[17];
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { 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_49: G = __r_arr[0];
         let __v_50: G = G::from_u64(0);
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_31, __v_32, __v_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_55] = [__v_54];
-        if let Some(result) = record.function_queries[55].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_56] = [__v_54];
+        if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_56: usize = 10;
-const IN_56: usize = 10;
-const OUT_56: usize = 1;
-fn aiur_fn_56(
-  inp: [G; IN_56],
+const INPUT_SIZE_57: usize = 10;
+const IN_57: usize = 10;
+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_56], 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];
@@ -9911,27 +9930,27 @@ fn aiur_fn_56(
         let __v_25: G = __loaded[15];
         let __v_26: G = __loaded[16];
         let __v_27: G = __loaded[17];
-        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_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_56] = [__v_29];
-        if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_57] = [__v_29];
+        if let Some(result) = record.function_queries[57].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_57: usize = 2;
-const IN_57: usize = 2;
-const OUT_57: usize = 1;
-fn aiur_fn_57(
-  inp: [G; IN_57],
+const INPUT_SIZE_58: usize = 2;
+const IN_58: usize = 2;
+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_57], 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];
@@ -9949,17 +9968,17 @@ fn aiur_fn_57(
     let __v_12: G = __loaded[10];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_57] = [__v_1];
-        if let Some(result) = record.function_queries[57].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_58] = [__v_1];
+        if let Some(result) = record.function_queries[58].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_57(__args, record, io_buffer, false)? } else { 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_58] = { let __args: [G; IN_58] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0];
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { 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_57] = { let __args: [G; IN_57] = [__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[57].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_57(__args, record, io_buffer, false)? } else { 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_14: G = __r_arr[0];
-        let __ret: [G; OUT_57] = [__v_14];
-        if let Some(result) = record.function_queries[57].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_58] = [__v_14];
+        if let Some(result) = record.function_queries[58].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -9969,15 +9988,15 @@ fn aiur_fn_57(
   })
 }
 
-const INPUT_SIZE_58: usize = 45;
-const IN_58: usize = 45;
-const OUT_58: usize = 1;
-fn aiur_fn_58(
-  inp: [G; IN_58],
+const INPUT_SIZE_59: usize = 45;
+const IN_59: usize = 45;
+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_58], 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];
@@ -10058,40 +10077,40 @@ fn aiur_fn_58(
         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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_57(__args, record, io_buffer, false)? } else { 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_58] = { let __args: [G; IN_58] = [__v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { 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_75: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_58] = [__v_83];
-        if let Some(result) = record.function_queries[58].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_59] = [__v_83];
+        if let Some(result) = record.function_queries[59].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_59: usize = 11;
-const IN_59: usize = 11;
-const OUT_59: usize = 1;
-fn aiur_fn_59(
-  inp: [G; IN_59],
+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_59], 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];
@@ -10126,28 +10145,28 @@ fn aiur_fn_59(
         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_33] = { let __args: [G; IN_33] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_59] = [__v_32];
-        if let Some(result) = record.function_queries[59].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_60] = [__v_32];
+        if let Some(result) = record.function_queries[60].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_60: usize = 11;
-const IN_60: usize = 11;
-const OUT_60: usize = 1;
-fn aiur_fn_60(
-  inp: [G; IN_60],
+const INPUT_SIZE_61: usize = 11;
+const IN_61: usize = 11;
+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_60], 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];
@@ -10181,29 +10200,29 @@ fn aiur_fn_60(
         let __v_26: G = __loaded[15];
         let __v_27: G = __loaded[16];
         let __v_28: G = __loaded[17];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_39] = { let __args: [G; IN_39] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { 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_40] = { let __args: [G; IN_40] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { 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_31: G = __r_arr[0];
-        let __ret: [G; OUT_60] = [__v_31];
-        if let Some(result) = record.function_queries[60].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_61] = [__v_31];
+        if let Some(result) = record.function_queries[61].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_61: usize = 35;
-const IN_61: usize = 35;
-const OUT_61: usize = 1;
-fn aiur_fn_61(
-  inp: [G; IN_61],
+const INPUT_SIZE_62: usize = 35;
+const IN_62: usize = 35;
+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_61], 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];
@@ -10262,34 +10281,34 @@ fn aiur_fn_61(
         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_33] = { let __args: [G; IN_33] = [__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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_61] = [__v_59];
-        if let Some(result) = record.function_queries[61].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_62] = [__v_59];
+        if let Some(result) = record.function_queries[62].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_62: usize = 2;
-const IN_62: usize = 2;
-const OUT_62: usize = 1;
-fn aiur_fn_62(
-  inp: [G; IN_62],
+const INPUT_SIZE_63: usize = 2;
+const IN_63: usize = 2;
+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_62], 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];
@@ -10332,17 +10351,17 @@ fn aiur_fn_62(
     let __v_37: G = __loaded[35];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_62] = [__v_1];
-        if let Some(result) = record.function_queries[62].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_63] = [__v_1];
+        if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_62(__args, record, io_buffer, false)? } else { 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_63] = { let __args: [G; IN_63] = [__v_37, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { 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_38: G = __r_arr[0];
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { 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_62] = { let __args: [G; IN_62] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[62].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_62(__args, record, io_buffer, false)? } else { 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_39: G = __r_arr[0];
-        let __ret: [G; OUT_62] = [__v_39];
-        if let Some(result) = record.function_queries[62].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_63] = [__v_39];
+        if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -10352,15 +10371,15 @@ fn aiur_fn_62(
   })
 }
 
-const INPUT_SIZE_63: usize = 28;
-const IN_63: usize = 28;
-const OUT_63: usize = 1;
-fn aiur_fn_63(
-  inp: [G; IN_63],
+const INPUT_SIZE_64: usize = 28;
+const IN_64: usize = 28;
+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_63], 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];
@@ -10421,36 +10440,36 @@ fn aiur_fn_63(
         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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_62(__args, record, io_buffer, false)? } else { 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_63] = { let __args: [G; IN_63] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { 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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_28, __v_29, __v_30, __v_31, __v_32, __v_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_63] = [__v_61];
-        if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_64] = [__v_61];
+        if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_64: usize = 10;
-const IN_64: usize = 10;
-const OUT_64: usize = 1;
-fn aiur_fn_64(
-  inp: [G; IN_64],
+const INPUT_SIZE_65: usize = 10;
+const IN_65: usize = 10;
+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_64], 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];
@@ -10464,27 +10483,27 @@ fn aiur_fn_64(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { 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_48] = { let __args: [G; IN_48] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { 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 __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_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_64] = [__v_11];
-        if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_65] = [__v_11];
+        if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_65: usize = 18;
-const IN_65: usize = 18;
-const OUT_65: usize = 1;
-fn aiur_fn_65(
-  inp: [G; IN_65],
+const INPUT_SIZE_66: usize = 18;
+const IN_66: usize = 18;
+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_65], 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];
@@ -10506,29 +10525,29 @@ fn aiur_fn_65(
     let __v_17: G = inp[17];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { 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_48] = { let __args: [G; IN_48] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_65] = [__v_20];
-        if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_66] = [__v_20];
+        if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_66: usize = 46;
-const IN_66: usize = 46;
-const OUT_66: usize = 1;
-fn aiur_fn_66(
-  inp: [G; IN_66],
+const INPUT_SIZE_67: usize = 46;
+const IN_67: usize = 46;
+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_66], 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];
@@ -10580,31 +10599,31 @@ fn aiur_fn_66(
       0u64 => {
         let __v_46: G = G::from_u64(0);
         let __v_47: G = G::from_u64(0);
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { 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_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
         let __v_48: G = __r_arr[0];
         let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_66] = [__v_49];
-        if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_67] = [__v_49];
+        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { 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_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_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_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[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { 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_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_66] = [__v_49];
-        if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_67] = [__v_49];
+        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { 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_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_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[59].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_59(__args, record, io_buffer, false)? } else { 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_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_66] = [__v_49];
-        if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_67] = [__v_49];
+        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -10614,15 +10633,15 @@ fn aiur_fn_66(
   })
 }
 
-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_68: usize = 2;
+const IN_68: usize = 2;
+const OUT_68: usize = 1;
+fn aiur_fn_68(
+  inp: [G; IN_68],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_67], 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];
@@ -10676,17 +10695,17 @@ fn aiur_fn_67(
     let __v_48: G = __loaded[46];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_67] = [__v_1];
-        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_68] = [__v_1];
+        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { 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_68] = { let __args: [G; IN_68] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { 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_49: G = __r_arr[0];
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { 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_67] = { let __args: [G; IN_67] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { 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_50: G = __r_arr[0];
-        let __ret: [G; OUT_67] = [__v_50];
-        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_68] = [__v_50];
+        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -10696,15 +10715,15 @@ fn aiur_fn_67(
   })
 }
 
-const INPUT_SIZE_68: usize = 46;
-const IN_68: usize = 46;
-const OUT_68: usize = 1;
-fn aiur_fn_68(
-  inp: [G; IN_68],
+const INPUT_SIZE_69: usize = 46;
+const IN_69: usize = 46;
+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_68], 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];
@@ -10754,59 +10773,59 @@ fn aiur_fn_68(
     let __v_45: G = inp[45];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { 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_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
         let __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_68] = [__v_46];
-        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_69] = [__v_46];
+        if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { 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_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_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[59].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_59(__args, record, io_buffer, false)? } else { 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_68] = [__v_46];
-        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_69] = [__v_46];
+        if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_59(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_60(__args, record, io_buffer, false)? } else { 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_68] = [__v_46];
-        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_69] = [__v_46];
+        if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_60(__args, record, io_buffer, false)? } else { 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_61] = { let __args: [G; IN_61] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { 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_46: G = __r_arr[0];
-        let __ret: [G; OUT_68] = [__v_46];
-        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_69] = [__v_46];
+        if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { 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_66] = { let __args: [G; IN_66] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_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[66].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { 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_46: G = __r_arr[0];
-        let __ret: [G; OUT_68] = [__v_46];
-        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_69] = [__v_46];
+        if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       5u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { 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_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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { 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_68] = [__v_46];
-        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_69] = [__v_46];
+        if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       6u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { 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_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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { 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_68] = [__v_46];
-        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_69] = [__v_46];
+        if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       7u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { 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_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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { 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_68] = [__v_46];
-        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_69] = [__v_46];
+        if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -10816,15 +10835,15 @@ fn aiur_fn_68(
   })
 }
 
-const INPUT_SIZE_69: usize = 2;
-const IN_69: usize = 2;
-const OUT_69: usize = 1;
-fn aiur_fn_69(
-  inp: [G; IN_69],
+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_69], 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];
@@ -10837,25 +10856,25 @@ fn aiur_fn_69(
     let __v_7: G = __r_arr[5];
     let __v_8: G = __r_arr[6];
     let __v_9: G = __r_arr[7];
-    let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_69] = [__v_11];
-    if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_70] = [__v_11];
+    if let Some(result) = record.function_queries[70].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_70: usize = 2;
-const IN_70: usize = 2;
-const OUT_70: usize = 1;
-fn aiur_fn_70(
-  inp: [G; IN_70],
+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_70], 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];
@@ -10868,25 +10887,25 @@ fn aiur_fn_70(
     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_54] = { let __args: [G; IN_54] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { 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_55] = { let __args: [G; IN_55] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_70] = [__v_11];
-    if let Some(result) = record.function_queries[70].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_71] = [__v_11];
+    if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_71: usize = 2;
-const IN_71: usize = 2;
-const OUT_71: usize = 1;
-fn aiur_fn_71(
-  inp: [G; IN_71],
+const INPUT_SIZE_72: usize = 2;
+const IN_72: usize = 2;
+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_71], 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];
@@ -10899,25 +10918,25 @@ fn aiur_fn_71(
     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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { 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_54] = { let __args: [G; IN_54] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_71] = [__v_11];
-    if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_72] = [__v_11];
+    if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_72: usize = 49;
-const IN_72: usize = 49;
-const OUT_72: usize = 1;
-fn aiur_fn_72(
-  inp: [G; IN_72],
+const INPUT_SIZE_73: usize = 49;
+const IN_73: usize = 49;
+const OUT_73: usize = 1;
+fn aiur_fn_73(
+  inp: [G; IN_73],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_72], ExecError> {
+) -> Result<[G; OUT_73], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10970,11 +10989,11 @@ fn aiur_fn_72(
     let __v_48: G = inp[48];
     match __v_0.as_canonical_u64() {
       _ => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { 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_72] = { let __args: [G; IN_72] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
         let __v_49: G = __r_arr[0];
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_70(__args, record, io_buffer, false)? } else { 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_71] = { let __args: [G; IN_71] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { 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_50: G = __r_arr[0];
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { 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_70] = { let __args: [G; IN_70] = [__v_45, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_70(__args, record, io_buffer, false)? } else { 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_51: G = __r_arr[0];
         match __v_0.as_canonical_u64() {
           8u64 => {
@@ -10988,12 +11007,12 @@ fn aiur_fn_72(
             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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { 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_68] = { let __args: [G; IN_68] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_72] = [__v_62];
-            if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_73] = [__v_62];
+            if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
@@ -11006,12 +11025,12 @@ fn aiur_fn_72(
             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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { 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_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_72] = [__v_62];
-            if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_73] = [__v_62];
+            if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
@@ -11024,12 +11043,12 @@ fn aiur_fn_72(
             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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { 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_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_72] = [__v_62];
-            if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_73] = [__v_62];
+            if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           2u64 => {
@@ -11042,12 +11061,12 @@ fn aiur_fn_72(
             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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { 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_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_72] = [__v_62];
-            if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_73] = [__v_62];
+            if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           3u64 => {
@@ -11060,12 +11079,12 @@ fn aiur_fn_72(
             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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { 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_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_72] = [__v_62];
-            if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_73] = [__v_62];
+            if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           4u64 => {
@@ -11078,12 +11097,12 @@ fn aiur_fn_72(
             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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { 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_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_72] = [__v_62];
-            if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_73] = [__v_62];
+            if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           5u64 => {
@@ -11096,12 +11115,12 @@ fn aiur_fn_72(
             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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { 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_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_72] = [__v_62];
-            if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_73] = [__v_62];
+            if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           6u64 => {
@@ -11114,12 +11133,12 @@ fn aiur_fn_72(
             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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { 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_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_72] = [__v_62];
-            if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_73] = [__v_62];
+            if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           7u64 => {
@@ -11132,12 +11151,12 @@ fn aiur_fn_72(
             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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { 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_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_72] = [__v_62];
-            if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_73] = [__v_62];
+            if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -11149,15 +11168,15 @@ fn aiur_fn_72(
   })
 }
 
-const INPUT_SIZE_73: usize = 1;
-const IN_73: usize = 1;
-const OUT_73: usize = 2;
-fn aiur_fn_73(
-  inp: [G; IN_73],
+const INPUT_SIZE_74: usize = 1;
+const IN_74: usize = 1;
+const OUT_74: usize = 2;
+fn aiur_fn_74(
+  inp: [G; IN_74],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_73], ExecError> {
+) -> Result<[G; OUT_74], 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 };
@@ -11166,8 +11185,8 @@ fn aiur_fn_73(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_73] = [__v_2, __v_3];
-        if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_74] = [__v_2, __v_3];
+        if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
@@ -11175,8 +11194,8 @@ fn aiur_fn_73(
         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_73] = [__v_4, __v_7];
-        if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_74] = [__v_4, __v_7];
+        if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -11186,15 +11205,15 @@ fn aiur_fn_73(
   })
 }
 
-const INPUT_SIZE_74: usize = 2;
-const IN_74: usize = 2;
-const OUT_74: usize = 9;
-fn aiur_fn_74(
-  inp: [G; IN_74],
+const INPUT_SIZE_75: usize = 2;
+const IN_75: usize = 2;
+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_74], ExecError> {
+) -> Result<[G; OUT_75], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11208,8 +11227,8 @@ fn aiur_fn_74(
         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_74] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0];
-        if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_75] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0];
+        if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -11221,7 +11240,7 @@ fn aiur_fn_74(
           0u64 => {
             let __v_5: G = G::from_u64(1);
             let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_7: G = __r_arr[0];
             let __v_8: G = __r_arr[1];
             let __v_9: G = __r_arr[2];
@@ -11231,8 +11250,8 @@ fn aiur_fn_74(
             let __v_13: G = __r_arr[6];
             let __v_14: G = __r_arr[7];
             let __v_15: G = __r_arr[8];
-            let __ret: [G; OUT_74] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15];
-            if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_75] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15];
+            if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -11244,15 +11263,15 @@ fn aiur_fn_74(
   })
 }
 
-const INPUT_SIZE_75: usize = 1;
-const IN_75: usize = 1;
-const OUT_75: usize = 9;
-fn aiur_fn_75(
-  inp: [G; IN_75],
+const INPUT_SIZE_76: usize = 1;
+const IN_76: usize = 1;
+const OUT_76: usize = 9;
+fn aiur_fn_76(
+  inp: [G; IN_76],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_75], ExecError> {
+) -> Result<[G; OUT_76], 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 };
@@ -11297,8 +11316,8 @@ fn aiur_fn_75(
             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 __ret: [G; OUT_75] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3];
-            if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_76] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3];
+            if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -11310,7 +11329,7 @@ fn aiur_fn_75(
             if (__v_33 != __v_34) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("tag0: payload width exceeds 8 bytes".to_string()) });
             }
-            let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_3, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
             let __v_37: G = __r_arr[2];
@@ -11320,8 +11339,8 @@ fn aiur_fn_75(
             let __v_41: G = __r_arr[6];
             let __v_42: G = __r_arr[7];
             let __v_43: G = __r_arr[8];
-            let __ret: [G; OUT_75] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43];
-            if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_76] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43];
+            if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -11333,15 +11352,15 @@ fn aiur_fn_75(
   })
 }
 
-const INPUT_SIZE_76: usize = 1;
-const IN_76: usize = 1;
-const OUT_76: usize = 10;
-fn aiur_fn_76(
-  inp: [G; IN_76],
+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_76], ExecError> {
+) -> Result<[G; OUT_77], 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 };
@@ -11383,14 +11402,14 @@ fn aiur_fn_76(
             let __v_31: G = G::from_u64(0);
             let __v_32: G = G::from_u64(0);
             let __v_33: G = G::from_u64(0);
-            let __ret: [G; OUT_76] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
-            if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_77] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
+            if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_27: G = G::from_u64(1);
             let __v_28: G = (__v_26 + __v_27);
-            let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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];
@@ -11406,8 +11425,8 @@ fn aiur_fn_76(
             if (__v_39 != __v_40) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: Some("tag2: payload width exceeds 8 bytes".to_string()) });
             }
-            let __ret: [G; OUT_76] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
-            if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_77] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
+            if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -11419,15 +11438,15 @@ fn aiur_fn_76(
   })
 }
 
-const INPUT_SIZE_77: usize = 1;
-const IN_77: usize = 1;
-const OUT_77: usize = 10;
-fn aiur_fn_77(
-  inp: [G; IN_77],
+const INPUT_SIZE_78: usize = 1;
+const IN_78: usize = 1;
+const OUT_78: usize = 10;
+fn aiur_fn_78(
+  inp: [G; IN_78],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_77], ExecError> {
+) -> Result<[G; OUT_78], 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 };
@@ -11469,14 +11488,14 @@ fn aiur_fn_77(
             let __v_31: G = G::from_u64(0);
             let __v_32: G = G::from_u64(0);
             let __v_33: G = G::from_u64(0);
-            let __ret: [G; OUT_77] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
-            if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_78] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
+            if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_27: G = G::from_u64(1);
             let __v_28: G = (__v_26 + __v_27);
-            let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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];
@@ -11486,8 +11505,8 @@ fn aiur_fn_77(
             let __v_35: G = __r_arr[6];
             let __v_36: G = __r_arr[7];
             let __v_37: G = __r_arr[8];
-            let __ret: [G; OUT_77] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
-            if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_78] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
+            if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -11499,15 +11518,15 @@ fn aiur_fn_77(
   })
 }
 
-const INPUT_SIZE_78: usize = 9;
-const IN_78: usize = 9;
-const OUT_78: usize = 2;
-fn aiur_fn_78(
-  inp: [G; IN_78],
+const INPUT_SIZE_79: usize = 9;
+const IN_79: usize = 9;
+const OUT_79: usize = 2;
+fn aiur_fn_79(
+  inp: [G; IN_79],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_78], 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];
@@ -11518,19 +11537,19 @@ fn aiur_fn_78(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_78] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_79] = [__v_12, __v_0];
+        if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -11540,7 +11559,7 @@ fn aiur_fn_78(
         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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { 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_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -11549,13 +11568,13 @@ fn aiur_fn_78(
         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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { 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_79] = { let __args: [G; IN_79] = [__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[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { 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_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_78] = [__v_30, __v_28];
-        if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_79] = [__v_30, __v_28];
+        if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -11565,15 +11584,15 @@ fn aiur_fn_78(
   })
 }
 
-const INPUT_SIZE_79: usize = 10;
-const IN_79: usize = 10;
-const OUT_79: usize = 2;
-fn aiur_fn_79(
-  inp: [G; IN_79],
+const INPUT_SIZE_80: usize = 10;
+const IN_80: usize = 10;
+const OUT_80: usize = 2;
+fn aiur_fn_80(
+  inp: [G; IN_80],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_79], 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];
@@ -11585,22 +11604,22 @@ fn aiur_fn_79(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_79] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_80] = [__v_0, __v_1];
+        if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = G::from_u64(7);
         let __v_14: G = G::from_u64(0);
         let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __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]; 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_15] = { let __args: [G; IN_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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { 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_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __v_17: G = __r_arr[1];
         let __v_18: G = __r_arr[2];
@@ -11609,11 +11628,11 @@ fn aiur_fn_79(
         let __v_21: G = __r_arr[5];
         let __v_22: G = __r_arr[6];
         let __v_23: G = __r_arr[7];
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_15, __v_12, __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[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { 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_80] = { let __args: [G; IN_80] = [__v_15, __v_12, __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[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { 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_24: G = __r_arr[0];
         let __v_25: G = __r_arr[1];
-        let __ret: [G; OUT_79] = [__v_24, __v_25];
-        if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_80] = [__v_24, __v_25];
+        if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -11623,15 +11642,15 @@ fn aiur_fn_79(
   })
 }
 
-const INPUT_SIZE_80: usize = 1;
-const IN_80: usize = 1;
-const OUT_80: usize = 2;
-fn aiur_fn_80(
-  inp: [G; IN_80],
+const INPUT_SIZE_81: usize = 1;
+const IN_81: usize = 1;
+const OUT_81: usize = 2;
+fn aiur_fn_81(
+  inp: [G; IN_81],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_80], ExecError> {
+) -> Result<[G; OUT_81], 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 };
@@ -11649,26 +11668,26 @@ fn aiur_fn_80(
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_80] = [__v_7, __v_3];
-            if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_81] = [__v_7, __v_3];
+            if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_80] = [__v_7, __v_3];
-            if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_81] = [__v_7, __v_3];
+            if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           2u64 => {
             let __v_7: G = G::from_u64(2);
-            let __ret: [G; OUT_80] = [__v_7, __v_3];
-            if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_81] = [__v_7, __v_3];
+            if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           3u64 => {
             let __v_7: G = G::from_u64(3);
-            let __ret: [G; OUT_80] = [__v_7, __v_3];
-            if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_81] = [__v_7, __v_3];
+            if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -11683,15 +11702,15 @@ fn aiur_fn_80(
   })
 }
 
-const INPUT_SIZE_81: usize = 1;
-const IN_81: usize = 1;
-const OUT_81: usize = 3;
-fn aiur_fn_81(
-  inp: [G; IN_81],
+const INPUT_SIZE_82: usize = 1;
+const IN_82: usize = 1;
+const OUT_82: usize = 3;
+fn aiur_fn_82(
+  inp: [G; IN_82],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_81], ExecError> {
+) -> Result<[G; OUT_82], 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 };
@@ -11710,57 +11729,57 @@ fn aiur_fn_81(
           0u64 => {
             let __v_7: G = G::from_u64(0);
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_81] = [__v_7, __v_8, __v_3];
-            if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
+            if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].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 __ret: [G; OUT_81] = [__v_7, __v_8, __v_3];
-            if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
+            if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].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 __ret: [G; OUT_81] = [__v_7, __v_8, __v_3];
-            if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
+            if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           3u64 => {
             let __v_7: G = G::from_u64(3);
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_81] = [__v_7, __v_8, __v_3];
-            if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
+            if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           4u64 => {
             let __v_7: G = G::from_u64(0);
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_81] = [__v_7, __v_8, __v_3];
-            if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
+            if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           5u64 => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_81] = [__v_7, __v_8, __v_3];
-            if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
+            if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           6u64 => {
             let __v_7: G = G::from_u64(2);
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_81] = [__v_7, __v_8, __v_3];
-            if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
+            if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           7u64 => {
             let __v_7: G = G::from_u64(3);
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_81] = [__v_7, __v_8, __v_3];
-            if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
+            if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -11775,102 +11794,6 @@ fn aiur_fn_81(
   })
 }
 
-const INPUT_SIZE_82: usize = 9;
-const IN_82: usize = 9;
-const OUT_82: usize = 2;
-fn aiur_fn_82(
-  inp: [G; IN_82],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_82], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
-    match __v_9.as_canonical_u64() {
-      1u64 => {
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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 __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        let __v_22: G = __loaded[10];
-        let __v_23: G = __loaded[11];
-        let __v_24: G = __loaded[12];
-        let __v_25: G = __loaded[13];
-        let __v_26: G = __loaded[14];
-        let __v_27: G = __loaded[15];
-        let __v_28: G = __loaded[16];
-        let __v_29: G = __loaded[17];
-        match __v_12.as_canonical_u64() {
-          8u64 => {
-            let __v_30: G = G::from_u64(0);
-            let __v_31: G = G::from_u64(1);
-            if (__v_30 != __v_31) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("non-canonical lambda telescope".to_string()) });
-            }
-            let __ret: [G; OUT_82] = [__v_10, __v_11];
-            if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __ret: [G; OUT_82] = [__v_10, __v_11];
-            if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = __r_arr[1];
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
-        let __v_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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__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[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
-        let __v_22: G = __r_arr[0];
-        let __v_23: G = __r_arr[1];
-        let __v_24: G = G::from_u64(8);
-        let __v_25: G = G::from_u64(0);
-        let __v_26: G = { let __values: [G; 18] = [__v_24, __v_10, __v_12, __v_22, __v_25, __v_25, __v_25, __v_25, __v_25, __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(&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_82] = [__v_26, __v_23];
-        if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-      },
-    }
-  })
-}
-
 const INPUT_SIZE_83: usize = 9;
 const IN_83: usize = 9;
 const OUT_83: usize = 2;
@@ -11890,11 +11813,11 @@ fn aiur_fn_83(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
@@ -11917,11 +11840,11 @@ fn aiur_fn_83(
         let __v_28: G = __loaded[16];
         let __v_29: G = __loaded[17];
         match __v_12.as_canonical_u64() {
-          9u64 => {
+          8u64 => {
             let __v_30: G = G::from_u64(0);
             let __v_31: G = G::from_u64(1);
             if (__v_30 != __v_31) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("non-canonical forall telescope".to_string()) });
+              return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("non-canonical lambda telescope".to_string()) });
             }
             let __ret: [G; OUT_83] = [__v_10, __v_11];
             if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -11938,11 +11861,107 @@ fn aiur_fn_83(
         let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
+        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __v_13: G = __r_arr[1];
+        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __v_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 __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__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[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { 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_22: G = __r_arr[0];
+        let __v_23: G = __r_arr[1];
+        let __v_24: G = G::from_u64(8);
+        let __v_25: G = G::from_u64(0);
+        let __v_26: G = { let __values: [G; 18] = [__v_24, __v_10, __v_12, __v_22, __v_25, __v_25, __v_25, __v_25, __v_25, __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(&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_83] = [__v_26, __v_23];
+        if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_84: usize = 9;
+const IN_84: usize = 9;
+const OUT_84: usize = 2;
+fn aiur_fn_84(
+  inp: [G; IN_84],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_84], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
+    match __v_9.as_canonical_u64() {
+      1u64 => {
+        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = __r_arr[1];
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __v_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        let __v_15: G = __loaded[3];
+        let __v_16: G = __loaded[4];
+        let __v_17: G = __loaded[5];
+        let __v_18: G = __loaded[6];
+        let __v_19: G = __loaded[7];
+        let __v_20: G = __loaded[8];
+        let __v_21: G = __loaded[9];
+        let __v_22: G = __loaded[10];
+        let __v_23: G = __loaded[11];
+        let __v_24: G = __loaded[12];
+        let __v_25: G = __loaded[13];
+        let __v_26: G = __loaded[14];
+        let __v_27: G = __loaded[15];
+        let __v_28: G = __loaded[16];
+        let __v_29: G = __loaded[17];
+        match __v_12.as_canonical_u64() {
+          9u64 => {
+            let __v_30: G = G::from_u64(0);
+            let __v_31: G = G::from_u64(1);
+            if (__v_30 != __v_31) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("non-canonical forall telescope".to_string()) });
+            }
+            let __ret: [G; OUT_84] = [__v_10, __v_11];
+            if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __ret: [G; OUT_84] = [__v_10, __v_11];
+            if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { 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];
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { 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_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
         let __v_15: G = __r_arr[0];
         let __v_16: G = __r_arr[1];
         let __v_17: G = __r_arr[2];
@@ -11951,14 +11970,14 @@ fn aiur_fn_83(
         let __v_20: G = __r_arr[5];
         let __v_21: G = __r_arr[6];
         let __v_22: G = __r_arr[7];
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { 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_84] = { let __args: [G; IN_84] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_23: G = __r_arr[0];
         let __v_24: G = __r_arr[1];
         let __v_25: G = G::from_u64(9);
         let __v_26: G = G::from_u64(0);
         let __v_27: G = { let __values: [G; 18] = [__v_25, __v_10, __v_11, __v_13, __v_23, __v_26, __v_26, __v_26, __v_26, __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(&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_83] = [__v_27, __v_24];
-        if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_84] = [__v_27, __v_24];
+        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -11968,18 +11987,18 @@ fn aiur_fn_83(
   })
 }
 
-const INPUT_SIZE_84: usize = 1;
-const IN_84: usize = 1;
-const OUT_84: usize = 2;
-fn aiur_fn_84(
-  inp: [G; IN_84],
+const INPUT_SIZE_85: usize = 1;
+const IN_85: usize = 1;
+const OUT_85: usize = 2;
+fn aiur_fn_85(
+  inp: [G; IN_85],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_84], 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_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_78] = { let __args: [G; IN_78] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -11995,20 +12014,20 @@ fn aiur_fn_84(
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 18] = [__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]; 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_84] = [__v_13, __v_10];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_85] = [__v_13, __v_10];
+        if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].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 __v_13: G = { let __values: [G; 18] = [__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]; 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_84] = [__v_13, __v_10];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_85] = [__v_13, __v_10];
+        if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -12018,18 +12037,18 @@ fn aiur_fn_84(
         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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { 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_79] = { let __args: [G; IN_79] = [__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[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { 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_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 __v_24: G = { let __values: [G; 18] = [__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]; 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_84] = [__v_24, __v_21];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_85] = [__v_24, __v_21];
+        if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -12039,18 +12058,18 @@ fn aiur_fn_84(
         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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { 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_79] = { let __args: [G; IN_79] = [__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[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { 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_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 __v_24: G = { let __values: [G; 18] = [__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]; 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_84] = [__v_24, __v_21];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_85] = [__v_24, __v_21];
+        if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -12060,36 +12079,36 @@ fn aiur_fn_84(
         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_84] = { let __args: [G; IN_84] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(4);
         let __v_23: G = { let __values: [G; 18] = [__v_22, __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_20]; 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_84] = [__v_23, __v_21];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_85] = [__v_23, __v_21];
+        if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].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 __v_13: G = { let __values: [G; 18] = [__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]; 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_84] = [__v_13, __v_10];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_85] = [__v_13, __v_10];
+        if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].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 __v_13: G = { let __values: [G; 18] = [__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]; 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_84] = [__v_13, __v_10];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_85] = [__v_13, __v_10];
+        if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
         if (__v_13 != __v_14) {
@@ -12121,65 +12140,65 @@ fn aiur_fn_84(
             if (__v_33 != __v_34) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("non-canonical application telescope".to_string()) });
             }
-            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_11, __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[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { 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_80] = { let __args: [G; IN_80] = [__v_11, __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[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { 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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __ret: [G; OUT_84] = [__v_35, __v_36];
-            if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_85] = [__v_35, __v_36];
+            if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_11, __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[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { 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_80] = { let __args: [G; IN_80] = [__v_11, __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[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } };
             let __v_33: G = __r_arr[0];
             let __v_34: G = __r_arr[1];
-            let __ret: [G; OUT_84] = [__v_33, __v_34];
-            if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_85] = [__v_33, __v_34];
+            if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       8u64 => {
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_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(), msg: Some("Lam with zero binders".to_string()) });
         }
-        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__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[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_84] = [__v_13, __v_14];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_85] = [__v_13, __v_14];
+        if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       9u64 => {
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_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(), msg: Some("All with zero binders".to_string()) });
         }
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { 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_84] = { let __args: [G; IN_84] = [__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[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_84] = [__v_13, __v_14];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_85] = [__v_13, __v_14];
+        if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       10u64 => {
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__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[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__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[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_84] = [__v_11, __v_12];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_85] = [__v_11, __v_12];
+        if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].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 __v_13: G = { let __values: [G; 18] = [__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]; 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_84] = [__v_13, __v_10];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_85] = [__v_13, __v_10];
+        if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -12189,15 +12208,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_86: usize = 9;
+const IN_86: usize = 9;
+const OUT_86: usize = 2;
+fn aiur_fn_86(
+  inp: [G; IN_86],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_85], ExecError> {
+) -> Result<[G; OUT_86], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12216,7 +12235,7 @@ fn aiur_fn_85(
     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 __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_12(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+    let __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, __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
     let __v_17: G = __r_arr[0];
     let __v_18: G = G::from_u64(1);
     let __v_19: G = G::from_u64(0);
@@ -12226,15 +12245,15 @@ fn aiur_fn_85(
     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 __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_12(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+    let __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, __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[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { 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_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
     let __v_27: G = __r_arr[0];
     let __v_28: G = __r_arr[1];
-    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
     let __v_29: G = __r_arr[0];
     let __v_30: G = __r_arr[1];
-    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
     let __v_31: G = __r_arr[0];
     let __v_32: G = __r_arr[1];
     let __v_33: G = (__v_17 + __v_26);
@@ -12245,21 +12264,21 @@ fn aiur_fn_85(
     let __v_35: G = G::from_u64(10);
     let __v_36: G = G::from_u64(0);
     let __v_37: G = { let __values: [G; 18] = [__v_35, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27, __v_29, __v_31, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; 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_85] = [__v_37, __v_32];
-    if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_86] = [__v_37, __v_32];
+    if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_86: usize = 17;
-const IN_86: usize = 17;
-const OUT_86: usize = 9;
-fn aiur_fn_86(
-  inp: [G; IN_86],
+const INPUT_SIZE_87: usize = 17;
+const IN_87: usize = 17;
+const OUT_87: usize = 9;
+fn aiur_fn_87(
+  inp: [G; IN_87],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_86], 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];
@@ -12278,16 +12297,16 @@ fn aiur_fn_86(
     let __v_14: G = inp[14];
     let __v_15: G = inp[15];
     let __v_16: G = inp[16];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_17: G = __r_arr[0];
     match __v_17.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_86] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_87] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { 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_16] = { let __args: [G; IN_16] = [__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[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -12296,7 +12315,7 @@ fn aiur_fn_86(
         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_86] = { let __args: [G; IN_86] = [__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[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0, __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[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { 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_26: G = __r_arr[0];
         let __v_27: G = __r_arr[1];
         let __v_28: G = __r_arr[2];
@@ -12309,8 +12328,8 @@ fn aiur_fn_86(
         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_86] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37];
-        if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_87] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37];
+        if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -12320,18 +12339,18 @@ fn aiur_fn_86(
   })
 }
 
-const INPUT_SIZE_87: usize = 1;
-const IN_87: usize = 1;
-const OUT_87: usize = 10;
-fn aiur_fn_87(
-  inp: [G; IN_87],
+const INPUT_SIZE_88: usize = 1;
+const IN_88: usize = 1;
+const OUT_88: usize = 10;
+fn aiur_fn_88(
+  inp: [G; IN_88],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_87], ExecError> {
+) -> Result<[G; OUT_88], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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];
@@ -12344,18 +12363,18 @@ fn aiur_fn_87(
     let __v_10: G = __r_arr[9];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
         match __v_11.as_canonical_u64() {
           1u64 => {
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_87] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10];
-            if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_88] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10];
+            if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { 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_88] = { let __args: [G; IN_88] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             let __v_14: G = __r_arr[2];
@@ -12366,7 +12385,7 @@ fn aiur_fn_87(
             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_86] = { let __args: [G; IN_86] = [__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[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { 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_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[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { 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_22: G = __r_arr[0];
             let __v_23: G = __r_arr[1];
             let __v_24: G = __r_arr[2];
@@ -12376,8 +12395,8 @@ fn aiur_fn_87(
             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_87] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21];
-            if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_88] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21];
+            if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -12386,7 +12405,7 @@ fn aiur_fn_87(
         }
       },
       1u64 => {
-        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { 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_88] = { let __args: [G; IN_88] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -12397,7 +12416,7 @@ fn aiur_fn_87(
         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_87] = { let __args: [G; IN_87] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { 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_88] = { let __args: [G; IN_88] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { 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_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = __r_arr[2];
@@ -12412,12 +12431,12 @@ fn aiur_fn_87(
         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_87] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
-        if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_88] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
+        if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { 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_88] = { let __args: [G; IN_88] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -12428,7 +12447,7 @@ fn aiur_fn_87(
         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_87] = { let __args: [G; IN_87] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { 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_88] = { let __args: [G; IN_88] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { 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_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = __r_arr[2];
@@ -12443,14 +12462,14 @@ fn aiur_fn_87(
         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_87] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
-        if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_88] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
+        if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
         let __v_11: G = G::from_u64(4);
-        let __ret: [G; OUT_87] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
-        if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_88] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
+        if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -12460,15 +12479,15 @@ fn aiur_fn_87(
   })
 }
 
-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_89: usize = 1;
+const IN_89: usize = 1;
+const OUT_89: usize = 2;
+fn aiur_fn_89(
+  inp: [G; IN_89],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_88], ExecError> {
+) -> Result<[G; OUT_89], 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 };
@@ -12664,8 +12683,8 @@ fn aiur_fn_88(
                                                                                                                                 match __v_94.as_canonical_u64() {
                                                                                                                                   0u64 => {
                                                                                                                                     let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                                                                                                    let __ret: [G; OUT_88] = [__v_97, __v_96];
-                                                                                                                                    if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                                                                                                    let __ret: [G; OUT_89] = [__v_97, __v_96];
+                                                                                                                                    if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                                                                                                     return Ok(__ret);
                                                                                                                                   },
                                                                                                                                   _ => {
@@ -12830,15 +12849,15 @@ fn aiur_fn_88(
   })
 }
 
-const INPUT_SIZE_89: usize = 9;
-const IN_89: usize = 9;
-const OUT_89: usize = 2;
-fn aiur_fn_89(
-  inp: [G; IN_89],
+const INPUT_SIZE_90: usize = 9;
+const IN_90: usize = 9;
+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_89], ExecError> {
+) -> Result<[G; OUT_90], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12849,22 +12868,22 @@ fn aiur_fn_89(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_89] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_90] = [__v_12, __v_0];
+        if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { 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_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -12873,13 +12892,13 @@ fn aiur_fn_89(
         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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_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[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { 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_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_89] = [__v_23, __v_21];
-        if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_90] = [__v_23, __v_21];
+        if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -12889,15 +12908,15 @@ fn aiur_fn_89(
   })
 }
 
-const INPUT_SIZE_90: usize = 9;
-const IN_90: usize = 9;
-const OUT_90: usize = 2;
-fn aiur_fn_90(
-  inp: [G; IN_90],
+const INPUT_SIZE_91: usize = 9;
+const IN_91: usize = 9;
+const OUT_91: usize = 2;
+fn aiur_fn_91(
+  inp: [G; IN_91],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_90], ExecError> {
+) -> Result<[G; OUT_91], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12908,19 +12927,19 @@ fn aiur_fn_90(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_90] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_91] = [__v_12, __v_0];
+        if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { 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_88] = { let __args: [G; IN_88] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { 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 __v_12: G = __r_arr[2];
@@ -12931,7 +12950,7 @@ fn aiur_fn_90(
         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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { 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_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -12940,14 +12959,14 @@ fn aiur_fn_90(
         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_90] = { let __args: [G; IN_90] = [__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[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_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[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { 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_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_90] = [__v_32, __v_29];
-        if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_91] = [__v_32, __v_29];
+        if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -12957,15 +12976,15 @@ fn aiur_fn_90(
   })
 }
 
-const INPUT_SIZE_91: usize = 9;
-const IN_91: usize = 9;
-const OUT_91: usize = 2;
-fn aiur_fn_91(
-  inp: [G; IN_91],
+const INPUT_SIZE_92: usize = 9;
+const IN_92: usize = 9;
+const OUT_92: usize = 2;
+fn aiur_fn_92(
+  inp: [G; IN_92],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_91], ExecError> {
+) -> Result<[G; OUT_92], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12976,22 +12995,22 @@ fn aiur_fn_91(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_91] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_92] = [__v_12, __v_0];
+        if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { 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_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -13000,13 +13019,13 @@ fn aiur_fn_91(
         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_91] = { let __args: [G; IN_91] = [__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[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_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[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { 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_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_91] = [__v_23, __v_21];
-        if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_92] = [__v_23, __v_21];
+        if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -13016,36 +13035,6 @@ fn aiur_fn_91(
   })
 }
 
-const INPUT_SIZE_92: usize = 1;
-const IN_92: usize = 1;
-const OUT_92: usize = 2;
-fn aiur_fn_92(
-  inp: [G; IN_92],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_92], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { 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_92] = [__v_10, __v_11];
-    if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { 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;
@@ -13057,7 +13046,7 @@ fn aiur_fn_93(
 ) -> Result<[G; OUT_93], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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];
@@ -13067,7 +13056,7 @@ fn aiur_fn_93(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__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[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { 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_90] = { let __args: [G; IN_90] = [__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[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __ret: [G; OUT_93] = [__v_10, __v_11];
@@ -13087,7 +13076,7 @@ fn aiur_fn_94(
 ) -> Result<[G; OUT_94], 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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];
@@ -13097,7 +13086,7 @@ fn aiur_fn_94(
     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_90] = { let __args: [G; IN_90] = [__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[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__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[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __ret: [G; OUT_94] = [__v_10, __v_11];
@@ -13115,70 +13104,100 @@ fn aiur_fn_95(
   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_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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];
+    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_91] = { let __args: [G; IN_91] = [__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[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
+    let __v_11: G = __r_arr[1];
+    let __ret: [G; OUT_95] = [__v_10, __v_11];
+    if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_96: usize = 1;
+const IN_96: usize = 1;
+const OUT_96: usize = 2;
+fn aiur_fn_96(
+  inp: [G; IN_96],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_96], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     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_95] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_96] = [__v_1, __v_2];
+        if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].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_95] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_96] = [__v_1, __v_2];
+        if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].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_95] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_96] = [__v_1, __v_2];
+        if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].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_95] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_96] = [__v_1, __v_2];
+        if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].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_95] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_96] = [__v_1, __v_2];
+        if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].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_95] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_96] = [__v_1, __v_2];
+        if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].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_95] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_96] = [__v_1, __v_2];
+        if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].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_95] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_96] = [__v_1, __v_2];
+        if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].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_95] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_96] = [__v_1, __v_2];
+        if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -13188,24 +13207,24 @@ fn aiur_fn_95(
   })
 }
 
-const INPUT_SIZE_96: usize = 1;
-const IN_96: usize = 1;
-const OUT_96: usize = 13;
-fn aiur_fn_96(
-  inp: [G; IN_96],
+const INPUT_SIZE_97: usize = 1;
+const IN_97: usize = 1;
+const OUT_97: usize = 13;
+fn aiur_fn_97(
+  inp: [G; IN_97],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_96], ExecError> {
+) -> Result<[G; OUT_97], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     let __v_7: G = __r_arr[2];
@@ -13215,30 +13234,30 @@ fn aiur_fn_96(
     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_84] = { let __args: [G; IN_84] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
     let __v_15: G = __r_arr[1];
-    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
     let __v_17: G = __r_arr[1];
-    let __ret: [G; OUT_96] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17];
-    if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_97] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17];
+    if let Some(result) = record.function_queries[97].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_97: usize = 1;
-const IN_97: usize = 1;
-const OUT_97: usize = 10;
-fn aiur_fn_97(
-  inp: [G; IN_97],
+const INPUT_SIZE_98: usize = 1;
+const IN_98: usize = 1;
+const OUT_98: usize = 10;
+fn aiur_fn_98(
+  inp: [G; IN_98],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_97], ExecError> {
+) -> Result<[G; OUT_98], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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];
@@ -13248,24 +13267,24 @@ fn aiur_fn_97(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_97] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
-    if let Some(result) = record.function_queries[97].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_98] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
+    if let Some(result) = record.function_queries[98].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_98: usize = 9;
-const IN_98: usize = 9;
-const OUT_98: usize = 2;
-fn aiur_fn_98(
-  inp: [G; IN_98],
+const INPUT_SIZE_99: usize = 9;
+const IN_99: usize = 9;
+const OUT_99: usize = 2;
+fn aiur_fn_99(
+  inp: [G; IN_99],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_98], ExecError> {
+) -> Result<[G; OUT_99], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13276,19 +13295,19 @@ fn aiur_fn_98(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_98] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[98].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_99] = [__v_12, __v_0];
+        if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -13298,10 +13317,10 @@ fn aiur_fn_98(
         let __v_16: G = __r_arr[6];
         let __v_17: G = __r_arr[7];
         let __v_18: G = __r_arr[8];
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { 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_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = __r_arr[2];
@@ -13310,13 +13329,13 @@ fn aiur_fn_98(
         let __v_26: G = __r_arr[5];
         let __v_27: G = __r_arr[6];
         let __v_28: G = __r_arr[7];
-        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__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[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_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[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { 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_29: G = __r_arr[0];
         let __v_30: G = __r_arr[1];
         let __v_31: G = G::from_u64(0);
         let __v_32: G = { let __values: [G; 11] = [__v_31, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_29]; 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_98] = [__v_32, __v_30];
-        if let Some(result) = record.function_queries[98].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_99] = [__v_32, __v_30];
+        if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -13326,18 +13345,18 @@ fn aiur_fn_98(
   })
 }
 
-const INPUT_SIZE_99: usize = 1;
-const IN_99: usize = 1;
-const OUT_99: usize = 45;
-fn aiur_fn_99(
-  inp: [G; IN_99],
+const INPUT_SIZE_100: usize = 1;
+const IN_100: usize = 1;
+const OUT_100: usize = 45;
+fn aiur_fn_100(
+  inp: [G; IN_100],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_99], ExecError> {
+) -> Result<[G; OUT_100], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
     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) };
@@ -13349,7 +13368,7 @@ fn aiur_fn_99(
     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_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -13359,7 +13378,7 @@ fn aiur_fn_99(
     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]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
     let __v_20: G = __r_arr[0];
     let __v_21: G = __r_arr[1];
     let __v_22: G = __r_arr[2];
@@ -13369,7 +13388,7 @@ fn aiur_fn_99(
     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_75] = { let __args: [G; IN_75] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_29: G = __r_arr[0];
     let __v_30: G = __r_arr[1];
     let __v_31: G = __r_arr[2];
@@ -13379,7 +13398,7 @@ fn aiur_fn_99(
     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_75] = { let __args: [G; IN_75] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -13389,7 +13408,7 @@ fn aiur_fn_99(
     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_75] = { let __args: [G; IN_75] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_47: G = __r_arr[0];
     let __v_48: G = __r_arr[1];
     let __v_49: G = __r_arr[2];
@@ -13399,10 +13418,10 @@ fn aiur_fn_99(
     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_84] = { let __args: [G; IN_84] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
     let __v_56: G = __r_arr[0];
     let __v_57: G = __r_arr[1];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_58: G = __r_arr[0];
     let __v_59: G = __r_arr[1];
     let __v_60: G = __r_arr[2];
@@ -13412,24 +13431,24 @@ fn aiur_fn_99(
     let __v_64: G = __r_arr[6];
     let __v_65: G = __r_arr[7];
     let __v_66: G = __r_arr[8];
-    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_66, __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[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_66, __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[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { 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_67: G = __r_arr[0];
     let __v_68: G = __r_arr[1];
-    let __ret: [G; OUT_99] = [__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_56, __v_67, __v_68];
-    if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_100] = [__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_56, __v_67, __v_68];
+    if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_100: usize = 1;
-const IN_100: usize = 1;
-const OUT_100: usize = 0;
-fn aiur_fn_100(
-  inp: [G; IN_100],
+const INPUT_SIZE_101: usize = 1;
+const IN_101: usize = 1;
+const OUT_101: usize = 0;
+fn aiur_fn_101(
+  inp: [G; IN_101],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_100], ExecError> {
+) -> Result<[G; OUT_101], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(2);
@@ -13438,28 +13457,28 @@ fn aiur_fn_100(
     if (__v_2 != __v_3) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("Bool byte is not 0 or 1".to_string()) });
     }
-    let __ret: [G; OUT_100] = [];
-    if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_101] = [];
+    if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].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 = 11;
-fn aiur_fn_101(
-  inp: [G; IN_101],
+const INPUT_SIZE_102: usize = 1;
+const IN_102: usize = 1;
+const OUT_102: usize = 11;
+fn aiur_fn_102(
+  inp: [G; IN_102],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_101], ExecError> {
+) -> Result<[G; OUT_102], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { 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_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -13469,49 +13488,49 @@ fn aiur_fn_101(
     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_84] = { let __args: [G; IN_84] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
-    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];
-    if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_102] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13];
+    if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].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 = 1;
-fn aiur_fn_102(
-  inp: [G; IN_102],
+const INPUT_SIZE_103: usize = 1;
+const IN_103: usize = 1;
+const OUT_103: usize = 1;
+fn aiur_fn_103(
+  inp: [G; IN_103],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_102], ExecError> {
+) -> Result<[G; OUT_103], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_1: G = G::from_u64(0);
-        let __ret: [G; OUT_102] = [__v_1];
-        if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_103] = [__v_1];
+        if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_102] = [__v_1];
-        if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_103] = [__v_1];
+        if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(2);
-        let __ret: [G; OUT_102] = [__v_1];
-        if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_103] = [__v_1];
+        if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
         let __v_1: G = G::from_u64(3);
-        let __ret: [G; OUT_102] = [__v_1];
-        if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_103] = [__v_1];
+        if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -13521,23 +13540,23 @@ fn aiur_fn_102(
   })
 }
 
-const INPUT_SIZE_103: usize = 1;
-const IN_103: usize = 1;
-const OUT_103: usize = 11;
-fn aiur_fn_103(
-  inp: [G; IN_103],
+const INPUT_SIZE_104: usize = 1;
+const IN_104: usize = 1;
+const OUT_104: usize = 11;
+fn aiur_fn_104(
+  inp: [G; IN_104],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_103], ExecError> {
+) -> Result<[G; OUT_104], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { 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 __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     let __v_6: G = __r_arr[2];
@@ -13547,31 +13566,31 @@ fn aiur_fn_103(
     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_84] = { let __args: [G; IN_84] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
-    let __ret: [G; OUT_103] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14];
-    if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_104] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14];
+    if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_104: usize = 1;
-const IN_104: usize = 1;
-const OUT_104: usize = 35;
-fn aiur_fn_104(
-  inp: [G; IN_104],
+const INPUT_SIZE_105: usize = 1;
+const IN_105: usize = 1;
+const OUT_105: usize = 35;
+fn aiur_fn_105(
+  inp: [G; IN_105],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_104], ExecError> {
+) -> Result<[G; OUT_105], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { 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_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -13581,7 +13600,7 @@ fn aiur_fn_104(
     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_75] = { let __args: [G; IN_75] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
     let __v_14: G = __r_arr[2];
@@ -13591,7 +13610,7 @@ fn aiur_fn_104(
     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_75] = { let __args: [G; IN_75] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -13601,7 +13620,7 @@ fn aiur_fn_104(
     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_75] = { let __args: [G; IN_75] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_30: G = __r_arr[0];
     let __v_31: G = __r_arr[1];
     let __v_32: G = __r_arr[2];
@@ -13611,24 +13630,24 @@ fn aiur_fn_104(
     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_84] = { let __args: [G; IN_84] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
     let __v_39: G = __r_arr[0];
     let __v_40: G = __r_arr[1];
-    let __ret: [G; OUT_104] = [__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_39, __v_40];
-    if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_105] = [__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_39, __v_40];
+    if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_105: usize = 9;
-const IN_105: usize = 9;
-const OUT_105: usize = 2;
-fn aiur_fn_105(
-  inp: [G; IN_105],
+const INPUT_SIZE_106: usize = 9;
+const IN_106: usize = 9;
+const OUT_106: usize = 2;
+fn aiur_fn_106(
+  inp: [G; IN_106],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_105], ExecError> {
+) -> Result<[G; OUT_106], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13639,19 +13658,19 @@ fn aiur_fn_105(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_105] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_106] = [__v_12, __v_0];
+        if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { 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];
@@ -13687,7 +13706,7 @@ fn aiur_fn_105(
         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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { 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_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
         let __v_45: G = __r_arr[0];
         let __v_46: G = __r_arr[1];
         let __v_47: G = __r_arr[2];
@@ -13696,13 +13715,13 @@ fn aiur_fn_105(
         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_105] = { let __args: [G; IN_105] = [__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[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_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[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { 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_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_105] = [__v_56, __v_54];
-        if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_106] = [__v_56, __v_54];
+        if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -13712,18 +13731,18 @@ fn aiur_fn_105(
   })
 }
 
-const INPUT_SIZE_106: usize = 1;
-const IN_106: usize = 1;
-const OUT_106: usize = 28;
-fn aiur_fn_106(
-  inp: [G; IN_106],
+const INPUT_SIZE_107: usize = 1;
+const IN_107: usize = 1;
+const OUT_107: usize = 28;
+fn aiur_fn_107(
+  inp: [G; IN_107],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_106], ExecError> {
+) -> Result<[G; OUT_107], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
     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) };
@@ -13735,7 +13754,7 @@ fn aiur_fn_106(
     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_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -13745,7 +13764,7 @@ fn aiur_fn_106(
     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]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
     let __v_20: G = __r_arr[0];
     let __v_21: G = __r_arr[1];
     let __v_22: G = __r_arr[2];
@@ -13755,7 +13774,7 @@ fn aiur_fn_106(
     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_75] = { let __args: [G; IN_75] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_29: G = __r_arr[0];
     let __v_30: G = __r_arr[1];
     let __v_31: G = __r_arr[2];
@@ -13765,10 +13784,10 @@ fn aiur_fn_106(
     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_84] = { let __args: [G; IN_84] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { 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_85] = { let __args: [G; IN_85] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
     let __v_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_40: G = __r_arr[0];
     let __v_41: G = __r_arr[1];
     let __v_42: G = __r_arr[2];
@@ -13778,27 +13797,27 @@ fn aiur_fn_106(
     let __v_46: G = __r_arr[6];
     let __v_47: G = __r_arr[7];
     let __v_48: G = __r_arr[8];
-    let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_48, __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[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_48, __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[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { 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_49: G = __r_arr[0];
     let __v_50: G = __r_arr[1];
-    let __ret: [G; OUT_106] = [__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_38, __v_49, __v_50];
-    if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_107] = [__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_38, __v_49, __v_50];
+    if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_107: usize = 1;
-const IN_107: usize = 1;
-const OUT_107: usize = 10;
-fn aiur_fn_107(
-  inp: [G; IN_107],
+const INPUT_SIZE_108: usize = 1;
+const IN_108: usize = 1;
+const OUT_108: usize = 10;
+fn aiur_fn_108(
+  inp: [G; IN_108],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_107], ExecError> {
+) -> Result<[G; OUT_108], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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];
@@ -13808,27 +13827,27 @@ fn aiur_fn_107(
     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_88] = { let __args: [G; IN_88] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { 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_107] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
-    if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_108] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
+    if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].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 = 18;
-fn aiur_fn_108(
-  inp: [G; IN_108],
+const INPUT_SIZE_109: usize = 1;
+const IN_109: usize = 1;
+const OUT_109: usize = 18;
+fn aiur_fn_109(
+  inp: [G; IN_109],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_108], ExecError> {
+) -> Result<[G; OUT_109], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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];
@@ -13838,7 +13857,7 @@ fn aiur_fn_108(
     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_75] = { let __args: [G; IN_75] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -13848,32 +13867,32 @@ fn aiur_fn_108(
     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_88] = { let __args: [G; IN_88] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { 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_19: G = __r_arr[0];
     let __v_20: G = __r_arr[1];
-    let __ret: [G; OUT_108] = [__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];
-    if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_109] = [__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];
+    if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_109: usize = 1;
-const IN_109: usize = 1;
-const OUT_109: usize = 46;
-fn aiur_fn_109(
-  inp: [G; IN_109],
+const INPUT_SIZE_110: usize = 1;
+const IN_110: usize = 1;
+const OUT_110: usize = 46;
+fn aiur_fn_110(
+  inp: [G; IN_110],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_109], ExecError> {
+) -> Result<[G; OUT_110], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
     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_96] = { let __args: [G; IN_96] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { 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];
@@ -13889,12 +13908,12 @@ fn aiur_fn_109(
         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_109] = [__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];
-        if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_110] = [__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];
+        if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -13925,12 +13944,12 @@ fn aiur_fn_109(
         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_109] = [__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];
-        if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_110] = [__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];
+        if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -13977,8 +13996,8 @@ fn aiur_fn_109(
         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_109] = [__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];
-        if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_110] = [__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];
+        if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -13988,15 +14007,15 @@ fn aiur_fn_109(
   })
 }
 
-const INPUT_SIZE_110: usize = 9;
-const IN_110: usize = 9;
-const OUT_110: usize = 2;
-fn aiur_fn_110(
-  inp: [G; IN_110],
+const INPUT_SIZE_111: usize = 9;
+const IN_111: usize = 9;
+const OUT_111: usize = 2;
+fn aiur_fn_111(
+  inp: [G; IN_111],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_110], ExecError> {
+) -> Result<[G; OUT_111], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14007,19 +14026,19 @@ fn aiur_fn_110(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_110] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_111] = [__v_12, __v_0];
+        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -14066,7 +14085,7 @@ fn aiur_fn_110(
         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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { 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_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
         let __v_57: G = __r_arr[1];
         let __v_58: G = __r_arr[2];
@@ -14075,13 +14094,13 @@ fn aiur_fn_110(
         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_110] = { let __args: [G; IN_110] = [__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[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_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[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
         let __v_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_110] = [__v_67, __v_65];
-        if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_111] = [__v_67, __v_65];
+        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -14091,21 +14110,21 @@ fn aiur_fn_110(
   })
 }
 
-const INPUT_SIZE_111: usize = 2;
-const IN_111: usize = 2;
-const OUT_111: usize = 46;
-fn aiur_fn_111(
-  inp: [G; IN_111],
+const INPUT_SIZE_112: usize = 2;
+const IN_112: usize = 2;
+const OUT_112: usize = 46;
+fn aiur_fn_112(
+  inp: [G; IN_112],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_111], ExecError> {
+) -> Result<[G; OUT_112], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { 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];
@@ -14121,12 +14140,12 @@ fn aiur_fn_111(
         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_111] = [__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];
-        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_112] = [__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];
+        if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { 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];
@@ -14173,12 +14192,12 @@ fn aiur_fn_111(
         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_111] = [__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];
-        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_112] = [__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];
+        if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -14192,12 +14211,12 @@ fn aiur_fn_111(
         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_111] = [__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];
-        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_112] = [__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];
+        if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { 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];
@@ -14211,12 +14230,12 @@ fn aiur_fn_111(
         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_111] = [__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];
-        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_112] = [__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];
+        if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -14237,12 +14256,12 @@ fn aiur_fn_111(
         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_111] = [__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];
-        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_112] = [__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];
+        if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -14255,12 +14274,12 @@ fn aiur_fn_111(
         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_111] = [__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];
-        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_112] = [__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];
+        if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -14273,12 +14292,12 @@ fn aiur_fn_111(
         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_111] = [__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];
-        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_112] = [__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];
+        if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -14291,8 +14310,8 @@ fn aiur_fn_111(
         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_111] = [__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];
-        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_112] = [__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];
+        if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -14302,15 +14321,15 @@ fn aiur_fn_111(
   })
 }
 
-const INPUT_SIZE_112: usize = 10;
-const IN_112: usize = 10;
-const OUT_112: usize = 46;
-fn aiur_fn_112(
-  inp: [G; IN_112],
+const INPUT_SIZE_113: usize = 10;
+const IN_113: usize = 10;
+const OUT_113: usize = 46;
+fn aiur_fn_113(
+  inp: [G; IN_113],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_112], ExecError> {
+) -> Result<[G; OUT_113], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14324,13 +14343,13 @@ fn aiur_fn_112(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       12u64 => {
-        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__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[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_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[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         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_112] = [__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];
-        if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_113] = [__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];
+        if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       13u64 => {
@@ -14344,7 +14363,7 @@ fn aiur_fn_112(
         if (__v_15 != __v_16) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("constant info: tag4 size exceeds a single byte".to_string()) });
         }
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
         let __v_17: G = __r_arr[0];
         let __v_18: G = __r_arr[1];
         let __v_19: G = __r_arr[2];
@@ -14391,8 +14410,8 @@ fn aiur_fn_112(
         let __v_60: G = __r_arr[43];
         let __v_61: G = __r_arr[44];
         let __v_62: G = __r_arr[45];
-        let __ret: [G; OUT_112] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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];
-        if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_113] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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];
+        if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -14402,18 +14421,18 @@ fn aiur_fn_112(
   })
 }
 
-const INPUT_SIZE_113: usize = 1;
-const IN_113: usize = 1;
-const OUT_113: usize = 49;
-fn aiur_fn_113(
-  inp: [G; IN_113],
+const INPUT_SIZE_114: usize = 1;
+const IN_114: usize = 1;
+const OUT_114: usize = 49;
+fn aiur_fn_114(
+  inp: [G; IN_114],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_113], ExecError> {
+) -> Result<[G; OUT_114], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_78] = { let __args: [G; IN_78] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -14426,7 +14445,7 @@ fn aiur_fn_113(
     let __v_10: G = __r_arr[9];
     let __mc_out___mc_0: [G; 46] = '__mc_0: { match __v_1.as_canonical_u64() {
   12u64 => {
-    let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__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[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_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[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = G::from_u64(8);
@@ -14444,7 +14463,7 @@ fn aiur_fn_113(
     if (__v_16 != __v_17) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("constant info: tag4 size exceeds a single byte".to_string()) });
     }
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
     let __v_19: G = __r_arr[1];
     let __v_20: G = __r_arr[2];
@@ -14544,7 +14563,7 @@ fn aiur_fn_113(
     let __v_54: G = __mc_out___mc_0[43];
     let __v_55: G = __mc_out___mc_0[44];
     let __v_56: G = __mc_out___mc_0[45];
-    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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_57: G = __r_arr[0];
     let __v_58: G = __r_arr[1];
     let __v_59: G = __r_arr[2];
@@ -14554,10 +14573,10 @@ fn aiur_fn_113(
     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_89] = { let __args: [G; IN_89] = [__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[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_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[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { 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_66: G = __r_arr[0];
     let __v_67: G = __r_arr[1];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_68: G = __r_arr[0];
     let __v_69: G = __r_arr[1];
     let __v_70: G = __r_arr[2];
@@ -14567,10 +14586,10 @@ fn aiur_fn_113(
     let __v_74: G = __r_arr[6];
     let __v_75: G = __r_arr[7];
     let __v_76: G = __r_arr[8];
-    let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { 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_77: G = __r_arr[0];
     let __v_78: G = __r_arr[1];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_79: G = __r_arr[0];
     let __v_80: G = __r_arr[1];
     let __v_81: G = __r_arr[2];
@@ -14580,24 +14599,24 @@ fn aiur_fn_113(
     let __v_85: G = __r_arr[6];
     let __v_86: G = __r_arr[7];
     let __v_87: G = __r_arr[8];
-    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { 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_88: G = __r_arr[0];
     let __v_89: G = __r_arr[1];
-    let __ret: [G; OUT_113] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_66, __v_77, __v_88, __v_89];
-    if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_114] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_66, __v_77, __v_88, __v_89];
+    if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_114: usize = 1;
-const IN_114: usize = 1;
-const OUT_114: usize = 2;
-fn aiur_fn_114(
-  inp: [G; IN_114],
+const INPUT_SIZE_115: usize = 1;
+const IN_115: usize = 1;
+const OUT_115: usize = 2;
+fn aiur_fn_115(
+  inp: [G; IN_115],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_114], ExecError> {
+) -> Result<[G; OUT_115], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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 };
@@ -14607,36 +14626,36 @@ fn aiur_fn_114(
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
         let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_114] = [__v_5, __v_7];
-        if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_115] = [__v_5, __v_7];
+        if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].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_114] = [__v_0, __v_7];
-        if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_115] = [__v_0, __v_7];
+        if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_115: usize = 1;
-const IN_115: usize = 1;
-const OUT_115: usize = 1;
-fn aiur_fn_115(
-  inp: [G; IN_115],
+const INPUT_SIZE_116: usize = 1;
+const IN_116: usize = 1;
+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_115], ExecError> {
+) -> Result<[G; OUT_116], 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 };
@@ -14665,8 +14684,8 @@ fn aiur_fn_115(
         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_115] = [__v_23];
-        if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_116] = [__v_23];
+        if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -14678,7 +14697,7 @@ fn aiur_fn_115(
         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_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { 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_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -14692,17 +14711,17 @@ fn aiur_fn_115(
           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_115] = [__v_29];
-            if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_116] = [__v_29];
+            if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_28: G = G::from_u64(0);
-            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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 __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_115] = [__v_30];
-            if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_116] = [__v_30];
+            if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -14714,15 +14733,15 @@ fn aiur_fn_115(
   })
 }
 
-const INPUT_SIZE_116: usize = 3;
-const IN_116: usize = 3;
-const OUT_116: usize = 1;
-fn aiur_fn_116(
-  inp: [G; IN_116],
+const INPUT_SIZE_117: usize = 3;
+const IN_117: usize = 3;
+const OUT_117: usize = 1;
+fn aiur_fn_117(
+  inp: [G; IN_117],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_116], ExecError> {
+) -> Result<[G; OUT_117], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14742,15 +14761,15 @@ fn aiur_fn_116(
       1u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_116] = [__v_1];
-            if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_117] = [__v_1];
+            if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_116] = [__v_13];
-            if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_117] = [__v_13];
+            if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -14771,21 +14790,21 @@ fn aiur_fn_116(
           1u64 => {
             match __v_2.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_116] = [__v_0];
-                if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_117] = [__v_0];
+                if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_23: G = __r_arr[0];
-                let __ret: [G; OUT_116] = [__v_23];
-                if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_117] = [__v_23];
+                if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
           },
           0u64 => {
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { 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_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { 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_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -14802,7 +14821,7 @@ fn aiur_fn_116(
             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_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { 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_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { 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_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
             let __v_41: G = __r_arr[2];
@@ -14814,11 +14833,11 @@ fn aiur_fn_116(
             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_116] = { let __args: [G; IN_116] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { 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_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_116] = [__v_51];
-            if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_117] = [__v_51];
+            if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -14833,36 +14852,36 @@ fn aiur_fn_116(
   })
 }
 
-const INPUT_SIZE_117: usize = 2;
-const IN_117: usize = 2;
-const OUT_117: usize = 1;
-fn aiur_fn_117(
-  inp: [G; IN_117],
+const INPUT_SIZE_118: usize = 2;
+const IN_118: usize = 2;
+const OUT_118: usize = 1;
+fn aiur_fn_118(
+  inp: [G; IN_118],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_117], ExecError> {
+) -> Result<[G; OUT_118], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
-    let __ret: [G; OUT_117] = [__v_3];
-    if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_118] = [__v_3];
+    if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_118: usize = 16;
-const IN_118: usize = 16;
-const OUT_118: usize = 9;
-fn aiur_fn_118(
-  inp: [G; IN_118],
+const INPUT_SIZE_119: usize = 16;
+const IN_119: usize = 16;
+const OUT_119: usize = 9;
+fn aiur_fn_119(
+  inp: [G; IN_119],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_118], ExecError> {
+) -> Result<[G; OUT_119], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14932,21 +14951,21 @@ fn aiur_fn_118(
     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_118] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
-    if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_119] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
+    if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_119: usize = 3;
-const IN_119: usize = 3;
-const OUT_119: usize = 2;
-fn aiur_fn_119(
-  inp: [G; IN_119],
+const INPUT_SIZE_120: usize = 3;
+const IN_120: usize = 3;
+const OUT_120: usize = 2;
+fn aiur_fn_120(
+  inp: [G; IN_120],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_119], ExecError> {
+) -> Result<[G; OUT_120], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14980,20 +14999,20 @@ fn aiur_fn_119(
             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_119] = [__v_25, __v_2];
-            if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_120] = [__v_25, __v_2];
+            if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_23: G = __r_arr[0];
             match __v_23.as_canonical_u64() {
               1u64 => {
                 let __v_24: G = G::from_u64(1);
                 let __v_25: G = G::from_u64(1);
                 let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_119] = [__v_26, __v_2];
-                if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_120] = [__v_26, __v_2];
+                if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -15001,8 +15020,8 @@ fn aiur_fn_119(
                 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 = G::from_u64(1);
-                let __ret: [G; OUT_119] = [__v_26, __v_27];
-                if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_120] = [__v_26, __v_27];
+                if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -15029,8 +15048,8 @@ fn aiur_fn_119(
             match __v_2.as_canonical_u64() {
               0u64 => {
                 let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_119] = [__v_0, __v_23];
-                if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_120] = [__v_0, __v_23];
+                if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -15042,7 +15061,7 @@ fn aiur_fn_119(
                 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_118] = { let __args: [G; IN_118] = [__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[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__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[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
                 let __v_31: G = __r_arr[0];
                 let __v_32: G = __r_arr[1];
                 let __v_33: G = __r_arr[2];
@@ -15055,19 +15074,19 @@ fn aiur_fn_119(
                 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_119] = { let __args: [G; IN_119] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
                 let __v_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_119] = [__v_46, __v_44];
-                if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_120] = [__v_46, __v_44];
+                if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
           },
           0u64 => {
-            let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__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[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__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[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -15084,7 +15103,7 @@ fn aiur_fn_119(
             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_118] = { let __args: [G; IN_118] = [__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[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__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[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
             let __v_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
             let __v_41: G = __r_arr[2];
@@ -15095,13 +15114,13 @@ fn aiur_fn_119(
             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_119] = { let __args: [G; IN_119] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
             let __v_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_119] = [__v_52, __v_50];
-            if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_120] = [__v_52, __v_50];
+            if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -15116,15 +15135,15 @@ fn aiur_fn_119(
   })
 }
 
-const INPUT_SIZE_120: usize = 1;
-const IN_120: usize = 1;
-const OUT_120: usize = 1;
-fn aiur_fn_120(
-  inp: [G; IN_120],
+const INPUT_SIZE_121: usize = 1;
+const IN_121: usize = 1;
+const OUT_121: usize = 1;
+fn aiur_fn_121(
+  inp: [G; IN_121],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_120], ExecError> {
+) -> Result<[G; OUT_121], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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 };
@@ -15143,8 +15162,8 @@ fn aiur_fn_120(
         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_120] = [__v_13];
-        if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_121] = [__v_13];
+        if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -15153,11 +15172,11 @@ fn aiur_fn_120(
         if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
         if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
         let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         let __v_13: G = { let __values: [G; 10] = [__v_11, __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 __ret: [G; OUT_120] = [__v_13];
-        if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_121] = [__v_13];
+        if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -15167,15 +15186,15 @@ fn aiur_fn_120(
   })
 }
 
-const INPUT_SIZE_121: usize = 1;
-const IN_121: usize = 1;
-const OUT_121: usize = 1;
-fn aiur_fn_121(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_121], ExecError> {
+) -> Result<[G; OUT_122], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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 };
@@ -15194,12 +15213,12 @@ fn aiur_fn_121(
         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_121] = [__v_13];
-        if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_122] = [__v_13];
+        if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __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];
@@ -15214,15 +15233,15 @@ fn aiur_fn_121(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_22: G = __r_arr[0];
             match __v_22.as_canonical_u64() {
               1u64 => {
                 let __v_23: G = G::from_u64(1);
                 let __v_24: G = G::from_u64(1);
                 let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_121] = [__v_25];
-                if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_122] = [__v_25];
+                if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               0u64 => {
@@ -15231,8 +15250,8 @@ fn aiur_fn_121(
                 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_121] = [__v_27];
-                if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_122] = [__v_27];
+                if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -15243,8 +15262,8 @@ fn aiur_fn_121(
           _ => {
             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_121] = [__v_23];
-            if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_122] = [__v_23];
+            if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -15256,20 +15275,20 @@ fn aiur_fn_121(
   })
 }
 
-const INPUT_SIZE_122: usize = 2;
-const IN_122: usize = 2;
-const OUT_122: usize = 1;
-fn aiur_fn_122(
-  inp: [G; IN_122],
+const INPUT_SIZE_123: usize = 2;
+const IN_123: usize = 2;
+const OUT_123: usize = 1;
+fn aiur_fn_123(
+  inp: [G; IN_123],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_122], ExecError> {
+) -> Result<[G; OUT_123], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -15277,15 +15296,15 @@ fn aiur_fn_122(
         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_122] = [__v_7];
-        if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_123] = [__v_7];
+        if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+        let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_122] = [__v_5];
-        if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_123] = [__v_5];
+        if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -15295,19 +15314,19 @@ fn aiur_fn_122(
   })
 }
 
-const INPUT_SIZE_123: usize = 2;
-const IN_123: usize = 2;
-const OUT_123: usize = 1;
-fn aiur_fn_123(
-  inp: [G; IN_123],
+const INPUT_SIZE_124: usize = 2;
+const IN_124: usize = 2;
+const OUT_124: usize = 1;
+fn aiur_fn_124(
+  inp: [G; IN_124],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_123], ExecError> {
+) -> Result<[G; OUT_124], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_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];
@@ -15323,29 +15342,29 @@ fn aiur_fn_123(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_13: G = G::from_u64(1);
-        let __ret: [G; OUT_123] = [__v_13];
-        if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_124] = [__v_13];
+        if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_123] = [__v_13];
-        if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_124] = [__v_13];
+        if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].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_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_124], ExecError> {
+) -> Result<[G; OUT_125], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -15361,23 +15380,23 @@ fn aiur_fn_124(
     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_122] = { let __args: [G; IN_122] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_14: G = __r_arr[0];
-    let __ret: [G; OUT_124] = [__v_14];
-    if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_125] = [__v_14];
+    if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].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 = 2;
-fn aiur_fn_125(
-  inp: [G; IN_125],
+const INPUT_SIZE_126: usize = 2;
+const IN_126: usize = 2;
+const OUT_126: usize = 2;
+fn aiur_fn_126(
+  inp: [G; IN_126],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_125], ExecError> {
+) -> Result<[G; OUT_126], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15385,8 +15404,8 @@ fn aiur_fn_125(
     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_125] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_126] = [__v_0, __v_1];
+        if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -15394,11 +15413,11 @@ fn aiur_fn_125(
         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_125] = { let __args: [G; IN_125] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_125] = [__v_8, __v_9];
-        if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_126] = [__v_8, __v_9];
+        if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -15408,40 +15427,40 @@ fn aiur_fn_125(
   })
 }
 
-const INPUT_SIZE_126: usize = 1;
-const IN_126: usize = 1;
-const OUT_126: usize = 3;
-fn aiur_fn_126(
-  inp: [G; IN_126],
+const INPUT_SIZE_127: usize = 1;
+const IN_127: usize = 1;
+const OUT_127: usize = 3;
+fn aiur_fn_127(
+  inp: [G; IN_127],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_126], ExecError> {
+) -> Result<[G; OUT_127], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
-    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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_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_125] = { let __args: [G; IN_125] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_126] = [__v_2, __v_5, __v_6];
-    if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_127] = [__v_2, __v_5, __v_6];
+    if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_127: usize = 16;
-const IN_127: usize = 16;
-const OUT_127: usize = 16;
-fn aiur_fn_127(
-  inp: [G; IN_127],
+const INPUT_SIZE_128: usize = 16;
+const IN_128: usize = 16;
+const OUT_128: usize = 16;
+fn aiur_fn_128(
+  inp: [G; IN_128],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_127], ExecError> {
+) -> Result<[G; OUT_128], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15572,7 +15591,7 @@ fn aiur_fn_127(
     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_126] = { let __args: [G; IN_126] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__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];
@@ -15595,7 +15614,7 @@ fn aiur_fn_127(
     if (__v_16 != __v_147) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_147.as_canonical_u64(), msg: Some("u64_mul column 0: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_141]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_141]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__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];
@@ -15618,7 +15637,7 @@ fn aiur_fn_127(
     if (__v_141 != __v_166) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("u64_mul column 1: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_160]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_160]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__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];
@@ -15641,7 +15660,7 @@ fn aiur_fn_127(
     if (__v_160 != __v_185) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("u64_mul column 2: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_179]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_179]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__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];
@@ -15664,7 +15683,7 @@ fn aiur_fn_127(
     if (__v_179 != __v_204) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_204.as_canonical_u64(), msg: Some("u64_mul column 3: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_198]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_198]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__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];
@@ -15687,7 +15706,7 @@ fn aiur_fn_127(
     if (__v_198 != __v_223) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_198.as_canonical_u64(), rhs: __v_223.as_canonical_u64(), msg: Some("u64_mul column 4: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_217]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_217]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__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];
@@ -15710,7 +15729,7 @@ fn aiur_fn_127(
     if (__v_217 != __v_242) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u64_mul column 5: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_236]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_236]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__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];
@@ -15733,7 +15752,7 @@ fn aiur_fn_127(
     if (__v_236 != __v_261) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_261.as_canonical_u64(), msg: Some("u64_mul column 6: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_255]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_255]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__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];
@@ -15756,7 +15775,7 @@ fn aiur_fn_127(
     if (__v_255 != __v_280) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_280.as_canonical_u64(), msg: Some("u64_mul column 7: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_274]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_274]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__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];
@@ -15779,7 +15798,7 @@ fn aiur_fn_127(
     if (__v_274 != __v_299) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_299.as_canonical_u64(), msg: Some("u64_mul column 8: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_293]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_293]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__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];
@@ -15802,7 +15821,7 @@ fn aiur_fn_127(
     if (__v_293 != __v_318) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_293.as_canonical_u64(), rhs: __v_318.as_canonical_u64(), msg: Some("u64_mul column 9: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_312]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_312]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__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];
@@ -15825,7 +15844,7 @@ fn aiur_fn_127(
     if (__v_312 != __v_337) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_312.as_canonical_u64(), rhs: __v_337.as_canonical_u64(), msg: Some("u64_mul column 10: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_331]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_331]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__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];
@@ -15848,7 +15867,7 @@ fn aiur_fn_127(
     if (__v_331 != __v_356) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_331.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: Some("u64_mul column 11: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_350]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_350]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__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];
@@ -15871,7 +15890,7 @@ fn aiur_fn_127(
     if (__v_350 != __v_375) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_350.as_canonical_u64(), rhs: __v_375.as_canonical_u64(), msg: Some("u64_mul column 12: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_369]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_369]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__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];
@@ -15894,7 +15913,7 @@ fn aiur_fn_127(
     if (__v_369 != __v_394) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_369.as_canonical_u64(), rhs: __v_394.as_canonical_u64(), msg: Some("u64_mul column 13: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_388]; let __cu = true; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_388]; let __cu = true; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__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];
@@ -15916,21 +15935,21 @@ fn aiur_fn_127(
     if (__v_388 != __v_412) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_412.as_canonical_u64(), msg: Some("u64_mul column 14: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __ret: [G; OUT_127] = [__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];
-    if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_128] = [__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];
+    if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_128: usize = 2;
-const IN_128: usize = 2;
-const OUT_128: usize = 1;
-fn aiur_fn_128(
-  inp: [G; IN_128],
+const INPUT_SIZE_129: usize = 2;
+const IN_129: usize = 2;
+const OUT_129: usize = 1;
+fn aiur_fn_129(
+  inp: [G; IN_129],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_128], ExecError> {
+) -> Result<[G; OUT_129], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15938,23 +15957,23 @@ fn aiur_fn_128(
     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_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_128] = [__v_6];
-    if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_129] = [__v_6];
+    if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_129: usize = 4;
-const IN_129: usize = 4;
-const OUT_129: usize = 1;
-fn aiur_fn_129(
-  inp: [G; IN_129],
+const INPUT_SIZE_130: usize = 4;
+const IN_130: usize = 4;
+const OUT_130: usize = 1;
+fn aiur_fn_130(
+  inp: [G; IN_130],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_129], ExecError> {
+) -> Result<[G; OUT_130], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15973,8 +15992,8 @@ fn aiur_fn_129(
     let __v_13: G = __loaded[9];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_129] = [__v_2];
-        if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_130] = [__v_2];
+        if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -15989,18 +16008,18 @@ fn aiur_fn_129(
         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_130] = { let __args: [G; IN_130] = [__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[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_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[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
         let __v_28: G = G::from_u64(1);
         let __v_29: G = (__v_3 + __v_28);
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
         let __v_30: G = __r_arr[0];
-        let __ret: [G; OUT_129] = [__v_30];
-        if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_130] = [__v_30];
+        if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -16010,15 +16029,15 @@ fn aiur_fn_129(
   })
 }
 
-const INPUT_SIZE_130: usize = 18;
-const IN_130: usize = 18;
-const OUT_130: usize = 1;
-fn aiur_fn_130(
-  inp: [G; IN_130],
+const INPUT_SIZE_131: usize = 18;
+const IN_131: usize = 18;
+const OUT_131: usize = 1;
+fn aiur_fn_131(
+  inp: [G; IN_131],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_130], ExecError> {
+) -> Result<[G; OUT_131], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16051,19 +16070,19 @@ fn aiur_fn_130(
     let __v_27: G = __loaded[9];
     match __v_18.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_28: G = __r_arr[0];
         match __v_28.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_130] = [__v_17];
-            if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_131] = [__v_17];
+            if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
             let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
             let __v_29: G = __r_arr[0];
-            let __ret: [G; OUT_130] = [__v_29];
-            if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_131] = [__v_29];
+            if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -16072,7 +16091,7 @@ fn aiur_fn_130(
         }
       },
       0u64 => {
-        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_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[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__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[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -16089,7 +16108,7 @@ fn aiur_fn_130(
         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_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { 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_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
         let __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -16106,7 +16125,7 @@ fn aiur_fn_130(
         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_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { 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_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { 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_60: G = __r_arr[0];
         let __v_61: G = __r_arr[1];
         let __v_62: G = __r_arr[2];
@@ -16118,10 +16137,10 @@ fn aiur_fn_130(
         let __v_68: G = __r_arr[8];
         let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
         let __v_69: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__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[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_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[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
         let __v_70: G = __r_arr[0];
-        let __ret: [G; OUT_130] = [__v_70];
-        if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_131] = [__v_70];
+        if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -16131,22 +16150,22 @@ fn aiur_fn_130(
   })
 }
 
-const INPUT_SIZE_131: usize = 2;
-const IN_131: usize = 2;
-const OUT_131: usize = 1;
-fn aiur_fn_131(
-  inp: [G; IN_131],
+const INPUT_SIZE_132: usize = 2;
+const IN_132: usize = 2;
+const OUT_132: usize = 1;
+fn aiur_fn_132(
+  inp: [G; IN_132],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_131], ExecError> {
+) -> Result<[G; OUT_132], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_131] = [__v_0];
-        if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_132] = [__v_0];
+        if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -16162,28 +16181,28 @@ fn aiur_fn_131(
         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_131] = { let __args: [G; IN_131] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_131] = [__v_14];
-        if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_132] = [__v_14];
+        if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_132: usize = 1;
-const IN_132: usize = 1;
-const OUT_132: usize = 1;
-fn aiur_fn_132(
-  inp: [G; IN_132],
+const INPUT_SIZE_133: usize = 1;
+const IN_133: usize = 1;
+const OUT_133: usize = 1;
+fn aiur_fn_133(
+  inp: [G; IN_133],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_132], ExecError> {
+) -> Result<[G; OUT_133], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
     let __v_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];
@@ -16199,79 +16218,79 @@ fn aiur_fn_132(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_132] = [__v_12];
-        if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_133] = [__v_12];
+        if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_132] = [__v_12];
-        if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_133] = [__v_12];
+        if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_133: usize = 2;
-const IN_133: usize = 2;
-const OUT_133: usize = 2;
-fn aiur_fn_133(
-  inp: [G; IN_133],
+const INPUT_SIZE_134: usize = 2;
+const IN_134: usize = 2;
+const OUT_134: usize = 2;
+fn aiur_fn_134(
+  inp: [G; IN_134],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_133], ExecError> {
+) -> Result<[G; OUT_134], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     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_120] = { let __args: [G; IN_120] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     if (__v_10 != __v_11) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("div/mod hint: q*b + r != a".to_string()) });
     }
-    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_12: G = __r_arr[0];
     match __v_12.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(1);
         if (__v_13 != __v_14) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("div/mod hint: division by zero must yield a zero quotient".to_string()) });
         }
-        let __ret: [G; OUT_133] = [__v_5, __v_7];
-        if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_134] = [__v_5, __v_7];
+        if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __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(), msg: Some("div/mod hint: remainder is not less than the divisor".to_string()) });
         }
-        let __ret: [G; OUT_133] = [__v_5, __v_7];
-        if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_134] = [__v_5, __v_7];
+        if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -16281,27 +16300,6 @@ fn aiur_fn_133(
   })
 }
 
-const INPUT_SIZE_134: usize = 2;
-const IN_134: usize = 2;
-const OUT_134: usize = 1;
-fn aiur_fn_134(
-  inp: [G; IN_134],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_134], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
-    let __v_3: G = __r_arr[1];
-    let __ret: [G; OUT_134] = [__v_2];
-    if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
 const INPUT_SIZE_135: usize = 2;
 const IN_135: usize = 2;
 const OUT_135: usize = 1;
@@ -16314,10 +16312,10 @@ fn aiur_fn_135(
   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_133] = { let __args: [G; IN_133] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
-    let __ret: [G; OUT_135] = [__v_3];
+    let __ret: [G; OUT_135] = [__v_2];
     if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
@@ -16335,21 +16333,42 @@ fn aiur_fn_136(
   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_132] = { let __args: [G; IN_132] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __ret: [G; OUT_136] = [__v_3];
+    if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_137: usize = 2;
+const IN_137: usize = 2;
+const OUT_137: usize = 1;
+fn aiur_fn_137(
+  inp: [G; IN_137],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_137], 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_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_136] = [__v_0];
-        if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_137] = [__v_0];
+        if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { 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_4: G = __r_arr[0];
-        let __ret: [G; OUT_136] = [__v_4];
-        if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_137] = [__v_4];
+        if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -16359,19 +16378,19 @@ fn aiur_fn_136(
   })
 }
 
-const INPUT_SIZE_137: usize = 2;
-const IN_137: usize = 2;
-const OUT_137: usize = 1;
-fn aiur_fn_137(
-  inp: [G; IN_137],
+const INPUT_SIZE_138: usize = 2;
+const IN_138: usize = 2;
+const OUT_138: usize = 1;
+fn aiur_fn_138(
+  inp: [G; IN_138],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_137], ExecError> {
+) -> Result<[G; OUT_138], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
@@ -16388,8 +16407,8 @@ fn aiur_fn_137(
         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_137] = [__v_15];
-        if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_138] = [__v_15];
+        if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -16406,30 +16425,30 @@ fn aiur_fn_137(
         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_133] = { let __args: [G; IN_133] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __v_17: G = __r_arr[1];
-        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { 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_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
         match __v_22.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_137] = [__v_21];
-            if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_138] = [__v_21];
+            if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_137] = [__v_23];
-            if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_138] = [__v_23];
+            if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -16444,15 +16463,15 @@ fn aiur_fn_137(
   })
 }
 
-const INPUT_SIZE_138: usize = 16;
-const IN_138: usize = 16;
-const OUT_138: usize = 8;
-fn aiur_fn_138(
-  inp: [G; IN_138],
+const INPUT_SIZE_139: usize = 16;
+const IN_139: usize = 16;
+const OUT_139: usize = 8;
+fn aiur_fn_139(
+  inp: [G; IN_139],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_138], ExecError> {
+) -> Result<[G; OUT_139], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16478,21 +16497,21 @@ fn aiur_fn_138(
     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_138] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_139] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_139: usize = 16;
-const IN_139: usize = 16;
-const OUT_139: usize = 8;
-fn aiur_fn_139(
-  inp: [G; IN_139],
+const INPUT_SIZE_140: usize = 16;
+const IN_140: usize = 16;
+const OUT_140: usize = 8;
+fn aiur_fn_140(
+  inp: [G; IN_140],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_139], ExecError> {
+) -> Result<[G; OUT_140], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16518,21 +16537,21 @@ fn aiur_fn_139(
     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_139] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_140] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_140: usize = 16;
-const IN_140: usize = 16;
-const OUT_140: usize = 8;
-fn aiur_fn_140(
-  inp: [G; IN_140],
+const INPUT_SIZE_141: usize = 16;
+const IN_141: usize = 16;
+const OUT_141: usize = 8;
+fn aiur_fn_141(
+  inp: [G; IN_141],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_140], ExecError> {
+) -> Result<[G; OUT_141], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16558,95 +16577,12 @@ fn aiur_fn_140(
     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_140] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_141] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_141: usize = 2;
-const IN_141: usize = 2;
-const OUT_141: usize = 1;
-fn aiur_fn_141(
-  inp: [G; IN_141],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_141], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_141] = [__v_14];
-        if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
-            let __v_22: G = G::from_u64(1);
-            let __v_23: G = G::from_u64(1);
-            let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_141] = [__v_24];
-            if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__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[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { 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_23: G = __r_arr[0];
-            let __v_24: G = __r_arr[1];
-            let __v_25: G = __r_arr[2];
-            let __v_26: G = __r_arr[3];
-            let __v_27: G = __r_arr[4];
-            let __v_28: G = __r_arr[5];
-            let __v_29: G = __r_arr[6];
-            let __v_30: G = __r_arr[7];
-            let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { 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_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_141] = [__v_32];
-            if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
 const INPUT_SIZE_142: usize = 2;
 const IN_142: usize = 2;
 const OUT_142: usize = 1;
@@ -16672,7 +16608,10 @@ fn aiur_fn_142(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_142] = [__v_1];
+        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_142] = [__v_14];
         if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
@@ -16690,7 +16629,10 @@ fn aiur_fn_142(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_142] = [__v_0];
+            let __v_22: G = G::from_u64(1);
+            let __v_23: G = G::from_u64(1);
+            let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_142] = [__v_24];
             if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
@@ -16810,6 +16752,83 @@ fn aiur_fn_144(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_144], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_144] = [__v_1];
+        if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        let __v_15: G = __loaded[3];
+        let __v_16: G = __loaded[4];
+        let __v_17: G = __loaded[5];
+        let __v_18: G = __loaded[6];
+        let __v_19: G = __loaded[7];
+        let __v_20: G = __loaded[8];
+        let __v_21: G = __loaded[9];
+        match __v_12.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_144] = [__v_0];
+            if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_22: G = G::from_u64(0);
+            let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__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[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { 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_23: G = __r_arr[0];
+            let __v_24: G = __r_arr[1];
+            let __v_25: G = __r_arr[2];
+            let __v_26: G = __r_arr[3];
+            let __v_27: G = __r_arr[4];
+            let __v_28: G = __r_arr[5];
+            let __v_29: G = __r_arr[6];
+            let __v_30: G = __r_arr[7];
+            let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
+            let __v_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_144] = [__v_32];
+            if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_145: usize = 2;
+const IN_145: usize = 2;
+const OUT_145: usize = 1;
+fn aiur_fn_145(
+  inp: [G; IN_145],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_145], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16826,25 +16845,25 @@ fn aiur_fn_144(
     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_137] = { let __args: [G; IN_137] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { 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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
-    let __ret: [G; OUT_144] = [__v_16];
-    if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_145] = [__v_16];
+    if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_145: usize = 2;
-const IN_145: usize = 2;
-const OUT_145: usize = 1;
-fn aiur_fn_145(
-  inp: [G; IN_145],
+const INPUT_SIZE_146: usize = 2;
+const IN_146: usize = 2;
+const OUT_146: usize = 1;
+fn aiur_fn_146(
+  inp: [G; IN_146],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_145], ExecError> {
+) -> Result<[G; OUT_146], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16861,25 +16880,25 @@ fn aiur_fn_145(
     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_137] = { let __args: [G; IN_137] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { 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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { 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_16: G = __r_arr[0];
-    let __ret: [G; OUT_145] = [__v_16];
-    if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_146] = [__v_16];
+    if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_146: usize = 0;
-const IN_146: usize = 0;
-const OUT_146: usize = 1;
-fn aiur_fn_146(
-  inp: [G; IN_146],
+const INPUT_SIZE_147: usize = 0;
+const IN_147: usize = 0;
+const OUT_147: usize = 1;
+fn aiur_fn_147(
+  inp: [G; IN_147],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_146], ExecError> {
+) -> Result<[G; OUT_147], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(80);
     let __v_1: G = G::from_u64(229);
@@ -16914,21 +16933,21 @@ fn aiur_fn_146(
     let __v_30: G = G::from_u64(12);
     let __v_31: G = G::from_u64(140);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_146] = [__v_32];
-    if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_147] = [__v_32];
+    if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_147: usize = 0;
-const IN_147: usize = 0;
-const OUT_147: usize = 1;
-fn aiur_fn_147(
-  inp: [G; IN_147],
+const INPUT_SIZE_148: usize = 0;
+const IN_148: usize = 0;
+const OUT_148: usize = 1;
+fn aiur_fn_148(
+  inp: [G; IN_148],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_147], ExecError> {
+) -> Result<[G; OUT_148], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(140);
     let __v_1: G = G::from_u64(9);
@@ -16963,21 +16982,21 @@ fn aiur_fn_147(
     let __v_30: G = G::from_u64(43);
     let __v_31: G = G::from_u64(12);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_147] = [__v_32];
-    if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_148] = [__v_32];
+    if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_148: usize = 0;
-const IN_148: usize = 0;
-const OUT_148: usize = 1;
-fn aiur_fn_148(
-  inp: [G; IN_148],
+const INPUT_SIZE_149: usize = 0;
+const IN_149: usize = 0;
+const OUT_149: usize = 1;
+fn aiur_fn_149(
+  inp: [G; IN_149],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_148], ExecError> {
+) -> Result<[G; OUT_149], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(252);
     let __v_1: G = G::from_u64(233);
@@ -17012,21 +17031,21 @@ fn aiur_fn_148(
     let __v_30: G = G::from_u64(214);
     let __v_31: G = G::from_u64(78);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_148] = [__v_32];
-    if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_149] = [__v_32];
+    if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_149: usize = 0;
-const IN_149: usize = 0;
-const OUT_149: usize = 1;
-fn aiur_fn_149(
-  inp: [G; IN_149],
+const INPUT_SIZE_150: usize = 0;
+const IN_150: usize = 0;
+const OUT_150: usize = 1;
+fn aiur_fn_150(
+  inp: [G; IN_150],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_149], ExecError> {
+) -> Result<[G; OUT_150], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(72);
     let __v_1: G = G::from_u64(120);
@@ -17061,21 +17080,21 @@ fn aiur_fn_149(
     let __v_30: G = G::from_u64(83);
     let __v_31: G = G::from_u64(155);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_149] = [__v_32];
-    if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_150] = [__v_32];
+    if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_150: usize = 0;
-const IN_150: usize = 0;
-const OUT_150: usize = 1;
-fn aiur_fn_150(
-  inp: [G; IN_150],
+const INPUT_SIZE_151: usize = 0;
+const IN_151: usize = 0;
+const OUT_151: usize = 1;
+fn aiur_fn_151(
+  inp: [G; IN_151],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_150], ExecError> {
+) -> Result<[G; OUT_151], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(207);
     let __v_1: G = G::from_u64(201);
@@ -17110,21 +17129,21 @@ fn aiur_fn_150(
     let __v_30: G = G::from_u64(14);
     let __v_31: G = G::from_u64(80);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_150] = [__v_32];
-    if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_151] = [__v_32];
+    if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_151: usize = 0;
-const IN_151: usize = 0;
-const OUT_151: usize = 1;
-fn aiur_fn_151(
-  inp: [G; IN_151],
+const INPUT_SIZE_152: usize = 0;
+const IN_152: usize = 0;
+const OUT_152: usize = 1;
+fn aiur_fn_152(
+  inp: [G; IN_152],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_151], ExecError> {
+) -> Result<[G; OUT_152], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(30);
     let __v_1: G = G::from_u64(96);
@@ -17159,21 +17178,21 @@ fn aiur_fn_151(
     let __v_30: G = G::from_u64(185);
     let __v_31: G = G::from_u64(100);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_151] = [__v_32];
-    if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_152] = [__v_32];
+    if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_152: usize = 0;
-const IN_152: usize = 0;
-const OUT_152: usize = 1;
-fn aiur_fn_152(
-  inp: [G; IN_152],
+const INPUT_SIZE_153: usize = 0;
+const IN_153: usize = 0;
+const OUT_153: usize = 1;
+fn aiur_fn_153(
+  inp: [G; IN_153],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_152], ExecError> {
+) -> Result<[G; OUT_153], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(13);
     let __v_1: G = G::from_u64(116);
@@ -17208,21 +17227,21 @@ fn aiur_fn_152(
     let __v_30: G = G::from_u64(24);
     let __v_31: G = G::from_u64(77);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_152] = [__v_32];
-    if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_153] = [__v_32];
+    if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_153: usize = 0;
-const IN_153: usize = 0;
-const OUT_153: usize = 1;
-fn aiur_fn_153(
-  inp: [G; IN_153],
+const INPUT_SIZE_154: usize = 0;
+const IN_154: usize = 0;
+const OUT_154: usize = 1;
+fn aiur_fn_154(
+  inp: [G; IN_154],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_153], ExecError> {
+) -> Result<[G; OUT_154], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(197);
     let __v_1: G = G::from_u64(190);
@@ -17257,21 +17276,21 @@ fn aiur_fn_153(
     let __v_30: G = G::from_u64(197);
     let __v_31: G = G::from_u64(90);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_153] = [__v_32];
-    if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_154] = [__v_32];
+    if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_154: usize = 0;
-const IN_154: usize = 0;
-const OUT_154: usize = 1;
-fn aiur_fn_154(
-  inp: [G; IN_154],
+const INPUT_SIZE_155: usize = 0;
+const IN_155: usize = 0;
+const OUT_155: usize = 1;
+fn aiur_fn_155(
+  inp: [G; IN_155],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_154], ExecError> {
+) -> Result<[G; OUT_155], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(188);
     let __v_1: G = G::from_u64(97);
@@ -17306,21 +17325,21 @@ fn aiur_fn_154(
     let __v_30: G = G::from_u64(75);
     let __v_31: G = G::from_u64(162);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_154] = [__v_32];
-    if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_155] = [__v_32];
+    if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_155: usize = 0;
-const IN_155: usize = 0;
-const OUT_155: usize = 1;
-fn aiur_fn_155(
-  inp: [G; IN_155],
+const INPUT_SIZE_156: usize = 0;
+const IN_156: usize = 0;
+const OUT_156: usize = 1;
+fn aiur_fn_156(
+  inp: [G; IN_156],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_155], ExecError> {
+) -> Result<[G; OUT_156], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(212);
     let __v_1: G = G::from_u64(53);
@@ -17355,21 +17374,21 @@ fn aiur_fn_155(
     let __v_30: G = G::from_u64(114);
     let __v_31: G = G::from_u64(39);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_155] = [__v_32];
-    if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_156] = [__v_32];
+    if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_156: usize = 0;
-const IN_156: usize = 0;
-const OUT_156: usize = 1;
-fn aiur_fn_156(
-  inp: [G; IN_156],
+const INPUT_SIZE_157: usize = 0;
+const IN_157: usize = 0;
+const OUT_157: usize = 1;
+fn aiur_fn_157(
+  inp: [G; IN_157],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_156], ExecError> {
+) -> Result<[G; OUT_157], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(62);
     let __v_1: G = G::from_u64(19);
@@ -17404,21 +17423,21 @@ fn aiur_fn_156(
     let __v_30: G = G::from_u64(203);
     let __v_31: G = G::from_u64(14);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_156] = [__v_32];
-    if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_157] = [__v_32];
+    if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_157: usize = 0;
-const IN_157: usize = 0;
-const OUT_157: usize = 1;
-fn aiur_fn_157(
-  inp: [G; IN_157],
+const INPUT_SIZE_158: usize = 0;
+const IN_158: usize = 0;
+const OUT_158: usize = 1;
+fn aiur_fn_158(
+  inp: [G; IN_158],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_157], ExecError> {
+) -> Result<[G; OUT_158], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(153);
     let __v_1: G = G::from_u64(112);
@@ -17453,21 +17472,21 @@ fn aiur_fn_157(
     let __v_30: G = G::from_u64(241);
     let __v_31: G = G::from_u64(156);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_157] = [__v_32];
-    if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_158] = [__v_32];
+    if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_158: usize = 0;
-const IN_158: usize = 0;
-const OUT_158: usize = 1;
-fn aiur_fn_158(
-  inp: [G; IN_158],
+const INPUT_SIZE_159: usize = 0;
+const IN_159: usize = 0;
+const OUT_159: usize = 1;
+fn aiur_fn_159(
+  inp: [G; IN_159],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_158], ExecError> {
+) -> Result<[G; OUT_159], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(134);
     let __v_1: G = G::from_u64(127);
@@ -17502,21 +17521,21 @@ fn aiur_fn_158(
     let __v_30: G = G::from_u64(70);
     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_158] = [__v_32];
-    if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_159] = [__v_32];
+    if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_159: usize = 0;
-const IN_159: usize = 0;
-const OUT_159: usize = 1;
-fn aiur_fn_159(
-  inp: [G; IN_159],
+const INPUT_SIZE_160: usize = 0;
+const IN_160: usize = 0;
+const OUT_160: usize = 1;
+fn aiur_fn_160(
+  inp: [G; IN_160],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_159], ExecError> {
+) -> Result<[G; OUT_160], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(33);
     let __v_1: G = G::from_u64(212);
@@ -17551,21 +17570,21 @@ fn aiur_fn_159(
     let __v_30: G = G::from_u64(85);
     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_159] = [__v_32];
-    if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_160] = [__v_32];
+    if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_160: usize = 0;
-const IN_160: usize = 0;
-const OUT_160: usize = 1;
-fn aiur_fn_160(
-  inp: [G; IN_160],
+const INPUT_SIZE_161: usize = 0;
+const IN_161: usize = 0;
+const OUT_161: usize = 1;
+fn aiur_fn_161(
+  inp: [G; IN_161],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_160], ExecError> {
+) -> Result<[G; OUT_161], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(135);
     let __v_1: G = G::from_u64(133);
@@ -17600,21 +17619,21 @@ fn aiur_fn_160(
     let __v_30: G = G::from_u64(173);
     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_160] = [__v_32];
-    if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_161] = [__v_32];
+    if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_161: usize = 0;
-const IN_161: usize = 0;
-const OUT_161: usize = 1;
-fn aiur_fn_161(
-  inp: [G; IN_161],
+const INPUT_SIZE_162: usize = 0;
+const IN_162: usize = 0;
+const OUT_162: usize = 1;
+fn aiur_fn_162(
+  inp: [G; IN_162],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_161], ExecError> {
+) -> Result<[G; OUT_162], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(249);
     let __v_1: G = G::from_u64(172);
@@ -17649,21 +17668,21 @@ fn aiur_fn_161(
     let __v_30: G = G::from_u64(84);
     let __v_31: G = G::from_u64(60);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_161] = [__v_32];
-    if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_162] = [__v_32];
+    if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_162: usize = 0;
-const IN_162: usize = 0;
-const OUT_162: usize = 1;
-fn aiur_fn_162(
-  inp: [G; IN_162],
+const INPUT_SIZE_163: usize = 0;
+const IN_163: usize = 0;
+const OUT_163: usize = 1;
+fn aiur_fn_163(
+  inp: [G; IN_163],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_162], ExecError> {
+) -> Result<[G; OUT_163], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(223);
     let __v_1: G = G::from_u64(56);
@@ -17698,21 +17717,21 @@ fn aiur_fn_162(
     let __v_30: G = G::from_u64(235);
     let __v_31: G = G::from_u64(9);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_162] = [__v_32];
-    if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_163] = [__v_32];
+    if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_163: usize = 0;
-const IN_163: usize = 0;
-const OUT_163: usize = 1;
-fn aiur_fn_163(
-  inp: [G; IN_163],
+const INPUT_SIZE_164: usize = 0;
+const IN_164: usize = 0;
+const OUT_164: usize = 1;
+fn aiur_fn_164(
+  inp: [G; IN_164],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_163], ExecError> {
+) -> Result<[G; OUT_164], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(243);
     let __v_1: G = G::from_u64(141);
@@ -17747,21 +17766,21 @@ fn aiur_fn_163(
     let __v_30: G = G::from_u64(22);
     let __v_31: G = G::from_u64(170);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_163] = [__v_32];
-    if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_164] = [__v_32];
+    if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_164: usize = 0;
-const IN_164: usize = 0;
-const OUT_164: usize = 1;
-fn aiur_fn_164(
-  inp: [G; IN_164],
+const INPUT_SIZE_165: usize = 0;
+const IN_165: usize = 0;
+const OUT_165: usize = 1;
+fn aiur_fn_165(
+  inp: [G; IN_165],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_164], ExecError> {
+) -> Result<[G; OUT_165], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(104);
     let __v_1: G = G::from_u64(246);
@@ -17796,21 +17815,21 @@ fn aiur_fn_164(
     let __v_30: G = G::from_u64(230);
     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_164] = [__v_32];
-    if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_165] = [__v_32];
+    if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_165: usize = 0;
-const IN_165: usize = 0;
-const OUT_165: usize = 1;
-fn aiur_fn_165(
-  inp: [G; IN_165],
+const INPUT_SIZE_166: usize = 0;
+const IN_166: usize = 0;
+const OUT_166: usize = 1;
+fn aiur_fn_166(
+  inp: [G; IN_166],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_165], ExecError> {
+) -> Result<[G; OUT_166], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(173);
     let __v_1: G = G::from_u64(71);
@@ -17845,21 +17864,21 @@ fn aiur_fn_165(
     let __v_30: G = G::from_u64(127);
     let __v_31: G = G::from_u64(3);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_165] = [__v_32];
-    if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_166] = [__v_32];
+    if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_166: usize = 0;
-const IN_166: usize = 0;
-const OUT_166: usize = 1;
-fn aiur_fn_166(
-  inp: [G; IN_166],
+const INPUT_SIZE_167: usize = 0;
+const IN_167: usize = 0;
+const OUT_167: usize = 1;
+fn aiur_fn_167(
+  inp: [G; IN_167],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_166], ExecError> {
+) -> Result<[G; OUT_167], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(246);
     let __v_1: G = G::from_u64(235);
@@ -17894,21 +17913,21 @@ fn aiur_fn_166(
     let __v_30: G = G::from_u64(13);
     let __v_31: G = G::from_u64(123);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_166] = [__v_32];
-    if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_167] = [__v_32];
+    if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_167: usize = 0;
-const IN_167: usize = 0;
-const OUT_167: usize = 1;
-fn aiur_fn_167(
-  inp: [G; IN_167],
+const INPUT_SIZE_168: usize = 0;
+const IN_168: usize = 0;
+const OUT_168: usize = 1;
+fn aiur_fn_168(
+  inp: [G; IN_168],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_167], ExecError> {
+) -> Result<[G; OUT_168], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(35);
     let __v_1: G = G::from_u64(23);
@@ -17943,21 +17962,21 @@ fn aiur_fn_167(
     let __v_30: G = G::from_u64(211);
     let __v_31: G = G::from_u64(231);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_167] = [__v_32];
-    if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_168] = [__v_32];
+    if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_168: usize = 0;
-const IN_168: usize = 0;
-const OUT_168: usize = 1;
-fn aiur_fn_168(
-  inp: [G; IN_168],
+const INPUT_SIZE_169: usize = 0;
+const IN_169: usize = 0;
+const OUT_169: usize = 1;
+fn aiur_fn_169(
+  inp: [G; IN_169],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_168], ExecError> {
+) -> Result<[G; OUT_169], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(143);
     let __v_1: G = G::from_u64(71);
@@ -17992,21 +18011,21 @@ fn aiur_fn_168(
     let __v_30: G = G::from_u64(111);
     let __v_31: G = G::from_u64(59);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_168] = [__v_32];
-    if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_169] = [__v_32];
+    if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_169: usize = 0;
-const IN_169: usize = 0;
-const OUT_169: usize = 1;
-fn aiur_fn_169(
-  inp: [G; IN_169],
+const INPUT_SIZE_170: usize = 0;
+const IN_170: usize = 0;
+const OUT_170: usize = 1;
+fn aiur_fn_170(
+  inp: [G; IN_170],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_169], ExecError> {
+) -> Result<[G; OUT_170], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(143);
     let __v_1: G = G::from_u64(60);
@@ -18041,21 +18060,21 @@ fn aiur_fn_169(
     let __v_30: G = G::from_u64(44);
     let __v_31: G = G::from_u64(99);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_169] = [__v_32];
-    if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_170] = [__v_32];
+    if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_170: usize = 0;
-const IN_170: usize = 0;
-const OUT_170: usize = 1;
-fn aiur_fn_170(
-  inp: [G; IN_170],
+const INPUT_SIZE_171: usize = 0;
+const IN_171: usize = 0;
+const OUT_171: usize = 1;
+fn aiur_fn_171(
+  inp: [G; IN_171],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_170], ExecError> {
+) -> Result<[G; OUT_171], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(128);
     let __v_1: G = G::from_u64(10);
@@ -18090,21 +18109,21 @@ fn aiur_fn_170(
     let __v_30: G = G::from_u64(253);
     let __v_31: G = G::from_u64(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 __ret: [G; OUT_170] = [__v_32];
-    if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_171] = [__v_32];
+    if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_171: usize = 0;
-const IN_171: usize = 0;
-const OUT_171: usize = 1;
-fn aiur_fn_171(
-  inp: [G; IN_171],
+const INPUT_SIZE_172: usize = 0;
+const IN_172: usize = 0;
+const OUT_172: usize = 1;
+fn aiur_fn_172(
+  inp: [G; IN_172],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_171], ExecError> {
+) -> Result<[G; OUT_172], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(84);
     let __v_1: G = G::from_u64(115);
@@ -18139,21 +18158,21 @@ fn aiur_fn_171(
     let __v_30: G = G::from_u64(12);
     let __v_31: G = G::from_u64(210);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_32];
-    if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_172] = [__v_32];
+    if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_172: usize = 0;
-const IN_172: usize = 0;
-const OUT_172: usize = 1;
-fn aiur_fn_172(
-  inp: [G; IN_172],
+const INPUT_SIZE_173: usize = 0;
+const IN_173: usize = 0;
+const OUT_173: usize = 1;
+fn aiur_fn_173(
+  inp: [G; IN_173],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_172], ExecError> {
+) -> Result<[G; OUT_173], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(27);
     let __v_1: G = G::from_u64(89);
@@ -18188,21 +18207,21 @@ fn aiur_fn_172(
     let __v_30: G = G::from_u64(190);
     let __v_31: G = G::from_u64(213);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_172] = [__v_32];
-    if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_173] = [__v_32];
+    if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_173: usize = 0;
-const IN_173: usize = 0;
-const OUT_173: usize = 1;
-fn aiur_fn_173(
-  inp: [G; IN_173],
+const INPUT_SIZE_174: usize = 0;
+const IN_174: usize = 0;
+const OUT_174: usize = 1;
+fn aiur_fn_174(
+  inp: [G; IN_174],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_173], ExecError> {
+) -> Result<[G; OUT_174], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(114);
     let __v_1: G = G::from_u64(198);
@@ -18237,21 +18256,21 @@ fn aiur_fn_173(
     let __v_30: G = G::from_u64(98);
     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_173] = [__v_32];
-    if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_174] = [__v_32];
+    if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_174: usize = 0;
-const IN_174: usize = 0;
-const OUT_174: usize = 1;
-fn aiur_fn_174(
-  inp: [G; IN_174],
+const INPUT_SIZE_175: usize = 0;
+const IN_175: usize = 0;
+const OUT_175: usize = 1;
+fn aiur_fn_175(
+  inp: [G; IN_175],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_174], ExecError> {
+) -> Result<[G; OUT_175], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(195);
     let __v_1: G = G::from_u64(127);
@@ -18286,21 +18305,21 @@ fn aiur_fn_174(
     let __v_30: G = G::from_u64(104);
     let __v_31: G = G::from_u64(142);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_32];
-    if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_175] = [__v_32];
+    if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_175: usize = 0;
-const IN_175: usize = 0;
-const OUT_175: usize = 1;
-fn aiur_fn_175(
-  inp: [G; IN_175],
+const INPUT_SIZE_176: usize = 0;
+const IN_176: usize = 0;
+const OUT_176: usize = 1;
+fn aiur_fn_176(
+  inp: [G; IN_176],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_175], ExecError> {
+) -> Result<[G; OUT_176], 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);
@@ -18335,21 +18354,21 @@ fn aiur_fn_175(
     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_175] = [__v_32];
-    if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_176] = [__v_32];
+    if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_176: usize = 0;
-const IN_176: usize = 0;
-const OUT_176: usize = 1;
-fn aiur_fn_176(
-  inp: [G; IN_176],
+const INPUT_SIZE_177: usize = 0;
+const IN_177: usize = 0;
+const OUT_177: usize = 1;
+fn aiur_fn_177(
+  inp: [G; IN_177],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_176], ExecError> {
+) -> Result<[G; OUT_177], 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);
@@ -18384,21 +18403,21 @@ fn aiur_fn_176(
     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_176] = [__v_32];
-    if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_177] = [__v_32];
+    if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_177: usize = 0;
-const IN_177: usize = 0;
-const OUT_177: usize = 1;
-fn aiur_fn_177(
-  inp: [G; IN_177],
+const INPUT_SIZE_178: usize = 0;
+const IN_178: usize = 0;
+const OUT_178: usize = 1;
+fn aiur_fn_178(
+  inp: [G; IN_178],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_177], ExecError> {
+) -> Result<[G; OUT_178], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(80);
     let __v_1: G = G::from_u64(96);
@@ -18433,21 +18452,21 @@ fn aiur_fn_177(
     let __v_30: G = G::from_u64(128);
     let __v_31: G = G::from_u64(13);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_32];
-    if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_178] = [__v_32];
+    if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_178: usize = 0;
-const IN_178: usize = 0;
-const OUT_178: usize = 1;
-fn aiur_fn_178(
-  inp: [G; IN_178],
+const INPUT_SIZE_179: usize = 0;
+const IN_179: usize = 0;
+const OUT_179: usize = 1;
+fn aiur_fn_179(
+  inp: [G; IN_179],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_178], ExecError> {
+) -> Result<[G; OUT_179], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(132);
     let __v_1: G = G::from_u64(254);
@@ -18482,21 +18501,21 @@ fn aiur_fn_178(
     let __v_30: G = G::from_u64(138);
     let __v_31: G = G::from_u64(37);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_178] = [__v_32];
-    if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_179] = [__v_32];
+    if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_179: usize = 0;
-const IN_179: usize = 0;
-const OUT_179: usize = 1;
-fn aiur_fn_179(
-  inp: [G; IN_179],
+const INPUT_SIZE_180: usize = 0;
+const IN_180: usize = 0;
+const OUT_180: usize = 1;
+fn aiur_fn_180(
+  inp: [G; IN_180],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_179], ExecError> {
+) -> Result<[G; OUT_180], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(212);
     let __v_1: G = G::from_u64(215);
@@ -18531,21 +18550,21 @@ fn aiur_fn_179(
     let __v_30: G = G::from_u64(38);
     let __v_31: G = G::from_u64(12);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_179] = [__v_32];
-    if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_180] = [__v_32];
+    if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_180: usize = 0;
-const IN_180: usize = 0;
-const OUT_180: usize = 1;
-fn aiur_fn_180(
-  inp: [G; IN_180],
+const INPUT_SIZE_181: usize = 0;
+const IN_181: usize = 0;
+const OUT_181: usize = 1;
+fn aiur_fn_181(
+  inp: [G; IN_181],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_180], ExecError> {
+) -> Result<[G; OUT_181], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(32);
     let __v_1: G = G::from_u64(117);
@@ -18580,21 +18599,21 @@ fn aiur_fn_180(
     let __v_30: G = G::from_u64(185);
     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_180] = [__v_32];
-    if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_181] = [__v_32];
+    if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_181: usize = 0;
-const IN_181: usize = 0;
-const OUT_181: usize = 1;
-fn aiur_fn_181(
-  inp: [G; IN_181],
+const INPUT_SIZE_182: usize = 0;
+const IN_182: usize = 0;
+const OUT_182: usize = 1;
+fn aiur_fn_182(
+  inp: [G; IN_182],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_181], ExecError> {
+) -> Result<[G; OUT_182], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(126);
     let __v_1: G = G::from_u64(78);
@@ -18629,21 +18648,21 @@ fn aiur_fn_181(
     let __v_30: G = G::from_u64(145);
     let __v_31: G = G::from_u64(88);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_181] = [__v_32];
-    if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_182] = [__v_32];
+    if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_182: usize = 0;
-const IN_182: usize = 0;
-const OUT_182: usize = 1;
-fn aiur_fn_182(
-  inp: [G; IN_182],
+const INPUT_SIZE_183: usize = 0;
+const IN_183: usize = 0;
+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_182], ExecError> {
+) -> Result<[G; OUT_183], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(128);
     let __v_1: G = G::from_u64(249);
@@ -18678,86 +18697,86 @@ fn aiur_fn_182(
     let __v_30: G = G::from_u64(78);
     let __v_31: G = G::from_u64(108);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_182] = [__v_32];
-    if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_183] = [__v_32];
+    if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_183: usize = 1;
-const IN_183: usize = 1;
-const OUT_183: usize = 1;
-fn aiur_fn_183(
-  inp: [G; IN_183],
+const INPUT_SIZE_184: usize = 1;
+const IN_184: usize = 1;
+const OUT_184: usize = 1;
+fn aiur_fn_184(
+  inp: [G; IN_184],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_183], ExecError> {
+) -> Result<[G; OUT_184], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_183] = [__v_3];
-        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_184] = [__v_3];
+        if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_183] = [__v_5];
-            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_184] = [__v_5];
+            if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             match __v_6.as_canonical_u64() {
               1u64 => {
                 let __v_7: G = G::from_u64(1);
-                let __ret: [G; OUT_183] = [__v_7];
-                if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_184] = [__v_7];
+                if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_8: G = __r_arr[0];
                 match __v_8.as_canonical_u64() {
                   1u64 => {
                     let __v_9: G = G::from_u64(1);
-                    let __ret: [G; OUT_183] = [__v_9];
-                    if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_184] = [__v_9];
+                    if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
                     let __v_9: G = __r_arr[0];
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
                     match __v_10.as_canonical_u64() {
                       1u64 => {
                         let __v_11: G = G::from_u64(1);
-                        let __ret: [G; OUT_183] = [__v_11];
-                        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_184] = [__v_11];
+                        if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_11: G = G::from_u64(0);
-                        let __ret: [G; OUT_183] = [__v_11];
-                        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_184] = [__v_11];
+                        if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
@@ -18772,15 +18791,15 @@ fn aiur_fn_183(
   })
 }
 
-const INPUT_SIZE_184: usize = 0;
-const IN_184: usize = 0;
-const OUT_184: usize = 1;
-fn aiur_fn_184(
-  inp: [G; IN_184],
+const INPUT_SIZE_185: usize = 0;
+const IN_185: usize = 0;
+const OUT_185: usize = 1;
+fn aiur_fn_185(
+  inp: [G; IN_185],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_184], ExecError> {
+) -> Result<[G; OUT_185], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(0);
     let __v_1: G = G::from_u64(64);
@@ -18799,21 +18818,21 @@ fn aiur_fn_184(
     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_184] = [__v_16];
-    if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_185] = [__v_16];
+    if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_185: usize = 0;
-const IN_185: usize = 0;
-const OUT_185: usize = 1;
-fn aiur_fn_185(
-  inp: [G; IN_185],
+const INPUT_SIZE_186: usize = 0;
+const IN_186: usize = 0;
+const OUT_186: usize = 1;
+fn aiur_fn_186(
+  inp: [G; IN_186],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_185], ExecError> {
+) -> Result<[G; OUT_186], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(0);
     let __v_1: G = G::from_u64(1);
@@ -18832,74 +18851,74 @@ fn aiur_fn_185(
     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_185] = [__v_16];
-    if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_186] = [__v_16];
+    if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_186: usize = 3;
-const IN_186: usize = 3;
-const OUT_186: usize = 2;
-fn aiur_fn_186(
-  inp: [G; IN_186],
+const INPUT_SIZE_187: usize = 3;
+const IN_187: usize = 3;
+const OUT_187: usize = 2;
+fn aiur_fn_187(
+  inp: [G; IN_187],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_186], ExecError> {
+) -> Result<[G; OUT_187], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_186] = [__v_5, __v_6];
-        if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_187] = [__v_5, __v_6];
+        if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_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_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_186] = [__v_7, __v_8];
-            if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_187] = [__v_7, __v_8];
+            if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
                 let __v_10: G = __r_arr[1];
-                let __ret: [G; OUT_186] = [__v_9, __v_10];
-                if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_187] = [__v_9, __v_10];
+                if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
                 let __v_13: G = (__v_10 + __v_12);
                 match __v_13.as_canonical_u64() {
@@ -18909,8 +18928,8 @@ fn aiur_fn_186(
                     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_186] = [__v_14, __v_18];
-                    if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_187] = [__v_14, __v_18];
+                    if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -18925,8 +18944,8 @@ fn aiur_fn_186(
                         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_186] = [__v_17, __v_21];
-                        if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_187] = [__v_17, __v_21];
+                        if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       _ => {
@@ -18937,19 +18956,19 @@ fn aiur_fn_186(
                         let __v_19: G = __r_arr[0];
                         match __v_10.as_canonical_u64() {
                           1u64 => {
-                            let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
                             let __v_20: G = __r_arr[0];
                             let __v_21: G = __r_arr[1];
-                            let __ret: [G; OUT_186] = [__v_20, __v_21];
-                            if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_187] = [__v_20, __v_21];
+                            if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
                             let __v_20: G = __r_arr[0];
                             let __v_21: G = __r_arr[1];
-                            let __ret: [G; OUT_186] = [__v_20, __v_21];
-                            if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_187] = [__v_20, __v_21];
+                            if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                         }
@@ -18966,15 +18985,15 @@ fn aiur_fn_186(
   })
 }
 
-const INPUT_SIZE_187: usize = 1;
-const IN_187: usize = 1;
-const OUT_187: usize = 2;
-fn aiur_fn_187(
-  inp: [G; IN_187],
+const INPUT_SIZE_188: usize = 1;
+const IN_188: usize = 1;
+const OUT_188: usize = 2;
+fn aiur_fn_188(
+  inp: [G; IN_188],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_187], ExecError> {
+) -> Result<[G; OUT_188], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
@@ -18988,15 +19007,15 @@ fn aiur_fn_187(
         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_187] = [__v_4, __v_8];
-        if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_188] = [__v_4, __v_8];
+        if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(2);
         let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         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 };
@@ -19006,17 +19025,17 @@ fn aiur_fn_187(
         let __v_11: G = __loaded[3];
         match __v_8.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_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_184] = { let __args: [G; IN_184] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
                 let __v_15: G = __r_arr[0];
-                let __ret: [G; OUT_187] = [__v_14, __v_15];
-                if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_188] = [__v_14, __v_15];
+                if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -19025,8 +19044,8 @@ fn aiur_fn_187(
                 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_187] = [__v_14, __v_18];
-                if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_188] = [__v_14, __v_18];
+                if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -19037,8 +19056,8 @@ fn aiur_fn_187(
             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_187] = [__v_12, __v_16];
-            if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_188] = [__v_12, __v_16];
+            if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -19047,15 +19066,15 @@ fn aiur_fn_187(
   })
 }
 
-const INPUT_SIZE_188: usize = 1;
-const IN_188: usize = 1;
-const OUT_188: usize = 2;
-fn aiur_fn_188(
-  inp: [G; IN_188],
+const INPUT_SIZE_189: usize = 1;
+const IN_189: usize = 1;
+const OUT_189: usize = 2;
+fn aiur_fn_189(
+  inp: [G; IN_189],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_188], ExecError> {
+) -> Result<[G; OUT_189], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -19065,13 +19084,13 @@ fn aiur_fn_188(
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = (__v_6 + __v_8);
         match __v_9.as_canonical_u64() {
@@ -19081,14 +19100,14 @@ fn aiur_fn_188(
             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_188] = [__v_10, __v_14];
-            if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_189] = [__v_10, __v_14];
+            if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(1);
-            let __ret: [G; OUT_188] = [__v_10, __v_0];
-            if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_189] = [__v_10, __v_0];
+            if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -19099,23 +19118,23 @@ fn aiur_fn_188(
         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_188] = [__v_5, __v_9];
-        if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_189] = [__v_5, __v_9];
+        if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_189: usize = 1;
-const IN_189: usize = 1;
-const OUT_189: usize = 2;
-fn aiur_fn_189(
-  inp: [G; IN_189],
+const INPUT_SIZE_190: usize = 1;
+const IN_190: usize = 1;
+const OUT_190: usize = 2;
+fn aiur_fn_190(
+  inp: [G; IN_190],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_189], ExecError> {
+) -> Result<[G; OUT_190], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -19128,8 +19147,8 @@ fn aiur_fn_189(
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_189] = [__v_5, __v_0];
-            if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_190] = [__v_5, __v_0];
+            if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -19138,8 +19157,8 @@ fn aiur_fn_189(
             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_189] = [__v_5, __v_9];
-            if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_190] = [__v_5, __v_9];
+            if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -19150,23 +19169,23 @@ fn aiur_fn_189(
         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_189] = [__v_5, __v_9];
-        if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_190] = [__v_5, __v_9];
+        if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_190: usize = 0;
-const IN_190: usize = 0;
-const OUT_190: usize = 1;
-fn aiur_fn_190(
-  inp: [G; IN_190],
+const INPUT_SIZE_191: usize = 0;
+const IN_191: usize = 0;
+const OUT_191: usize = 1;
+fn aiur_fn_191(
+  inp: [G; IN_191],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_190], ExecError> {
+) -> Result<[G; OUT_191], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(172);
     let __v_1: G = G::from_u64(217);
@@ -19201,21 +19220,21 @@ fn aiur_fn_190(
     let __v_30: G = G::from_u64(103);
     let __v_31: G = G::from_u64(141);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_190] = [__v_32];
-    if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_191] = [__v_32];
+    if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_191: usize = 0;
-const IN_191: usize = 0;
-const OUT_191: usize = 1;
-fn aiur_fn_191(
-  inp: [G; IN_191],
+const INPUT_SIZE_192: usize = 0;
+const IN_192: usize = 0;
+const OUT_192: usize = 1;
+fn aiur_fn_192(
+  inp: [G; IN_192],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_191], ExecError> {
+) -> Result<[G; OUT_192], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(87);
     let __v_1: G = G::from_u64(33);
@@ -19250,21 +19269,21 @@ fn aiur_fn_191(
     let __v_30: G = G::from_u64(219);
     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_191] = [__v_32];
-    if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_192] = [__v_32];
+    if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_192: usize = 0;
-const IN_192: usize = 0;
-const OUT_192: usize = 1;
-fn aiur_fn_192(
-  inp: [G; IN_192],
+const INPUT_SIZE_193: usize = 0;
+const IN_193: usize = 0;
+const OUT_193: usize = 1;
+fn aiur_fn_193(
+  inp: [G; IN_193],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_192], ExecError> {
+) -> Result<[G; OUT_193], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(199);
     let __v_1: G = G::from_u64(25);
@@ -19299,21 +19318,21 @@ fn aiur_fn_192(
     let __v_30: G = G::from_u64(176);
     let __v_31: G = G::from_u64(74);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_192] = [__v_32];
-    if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_193] = [__v_32];
+    if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_193: usize = 0;
-const IN_193: usize = 0;
-const OUT_193: usize = 1;
-fn aiur_fn_193(
-  inp: [G; IN_193],
+const INPUT_SIZE_194: usize = 0;
+const IN_194: usize = 0;
+const OUT_194: usize = 1;
+fn aiur_fn_194(
+  inp: [G; IN_194],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_193], ExecError> {
+) -> Result<[G; OUT_194], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(141);
     let __v_1: G = G::from_u64(87);
@@ -19348,21 +19367,21 @@ fn aiur_fn_193(
     let __v_30: G = G::from_u64(30);
     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_193] = [__v_32];
-    if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_194] = [__v_32];
+    if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_194: usize = 0;
-const IN_194: usize = 0;
-const OUT_194: usize = 1;
-fn aiur_fn_194(
-  inp: [G; IN_194],
+const INPUT_SIZE_195: usize = 0;
+const IN_195: usize = 0;
+const OUT_195: usize = 1;
+fn aiur_fn_195(
+  inp: [G; IN_195],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_194], ExecError> {
+) -> Result<[G; OUT_195], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(209);
     let __v_1: G = G::from_u64(16);
@@ -19397,21 +19416,21 @@ fn aiur_fn_194(
     let __v_30: G = G::from_u64(126);
     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_194] = [__v_32];
-    if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_195] = [__v_32];
+    if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_195: usize = 0;
-const IN_195: usize = 0;
-const OUT_195: usize = 1;
-fn aiur_fn_195(
-  inp: [G; IN_195],
+const INPUT_SIZE_196: usize = 0;
+const IN_196: usize = 0;
+const OUT_196: usize = 1;
+fn aiur_fn_196(
+  inp: [G; IN_196],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_195], ExecError> {
+) -> Result<[G; OUT_196], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(198);
     let __v_1: G = G::from_u64(157);
@@ -19446,62 +19465,62 @@ fn aiur_fn_195(
     let __v_30: G = G::from_u64(111);
     let __v_31: G = G::from_u64(4);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_195] = [__v_32];
-    if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_196] = [__v_32];
+    if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_196: usize = 1;
-const IN_196: usize = 1;
-const OUT_196: usize = 1;
-fn aiur_fn_196(
-  inp: [G; IN_196],
+const INPUT_SIZE_197: usize = 1;
+const IN_197: usize = 1;
+const OUT_197: usize = 1;
+fn aiur_fn_197(
+  inp: [G; IN_197],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_196], ExecError> {
+) -> Result<[G; OUT_197], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_196] = [__v_3];
-        if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_197] = [__v_3];
+        if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_196] = [__v_5];
-            if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_197] = [__v_5];
+            if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             match __v_6.as_canonical_u64() {
               1u64 => {
                 let __v_7: G = G::from_u64(1);
-                let __ret: [G; OUT_196] = [__v_7];
-                if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_197] = [__v_7];
+                if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_7: G = G::from_u64(0);
-                let __ret: [G; OUT_196] = [__v_7];
-                if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_197] = [__v_7];
+                if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -19512,61 +19531,61 @@ fn aiur_fn_196(
   })
 }
 
-const INPUT_SIZE_197: usize = 1;
-const IN_197: usize = 1;
-const OUT_197: usize = 1;
-fn aiur_fn_197(
-  inp: [G; IN_197],
+const INPUT_SIZE_198: usize = 1;
+const IN_198: usize = 1;
+const OUT_198: usize = 1;
+fn aiur_fn_198(
+  inp: [G; IN_198],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_197], ExecError> {
+) -> Result<[G; OUT_198], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_1: G = G::from_u64(2);
-        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = G::from_u64(1);
         let __v_4: G = G::from_u64(1);
         let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_6: G = G::from_u64(0);
         let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_197] = [__v_7];
-        if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_198] = [__v_7];
+        if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_1: G = G::from_u64(2);
-        let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = G::from_u64(1);
         let __v_4: G = G::from_u64(1);
         let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_6: G = G::from_u64(0);
         let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_197] = [__v_7];
-        if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_198] = [__v_7];
+        if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_198: usize = 2;
-const IN_198: usize = 2;
-const OUT_198: usize = 2;
-fn aiur_fn_198(
-  inp: [G; IN_198],
+const INPUT_SIZE_199: usize = 2;
+const IN_199: usize = 2;
+const OUT_199: usize = 2;
+fn aiur_fn_199(
+  inp: [G; IN_199],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_198], ExecError> {
+) -> Result<[G; OUT_199], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -19576,12 +19595,12 @@ fn aiur_fn_198(
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_198] = [__v_5, __v_8];
-        if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_199] = [__v_5, __v_8];
+        if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
         match __v_5.as_canonical_u64() {
@@ -19590,12 +19609,12 @@ fn aiur_fn_198(
             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_198] = [__v_7, __v_10];
-            if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_199] = [__v_7, __v_10];
+            if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __v_8: G = __r_arr[1];
             match __v_7.as_canonical_u64() {
@@ -19604,8 +19623,8 @@ fn aiur_fn_198(
                 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_198] = [__v_9, __v_12];
-                if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_199] = [__v_9, __v_12];
+                if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               1u64 => {
@@ -19622,15 +19641,15 @@ fn aiur_fn_198(
                 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 __v_21: G = { let __values: [G; 10] = [__v_9, __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 __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_21, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_21, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { 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_22: G = __r_arr[0];
                 let __v_23: G = G::from_u64(1);
-                let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_6, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_6, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { 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_24: G = __r_arr[0];
-                let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                 let __v_25: G = __r_arr[0];
-                let __ret: [G; OUT_198] = [__v_23, __v_25];
-                if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_199] = [__v_23, __v_25];
+                if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -19650,15 +19669,15 @@ fn aiur_fn_198(
   })
 }
 
-const INPUT_SIZE_199: usize = 1;
-const IN_199: usize = 1;
-const OUT_199: usize = 2;
-fn aiur_fn_199(
-  inp: [G; IN_199],
+const INPUT_SIZE_200: usize = 1;
+const IN_200: usize = 1;
+const OUT_200: usize = 2;
+fn aiur_fn_200(
+  inp: [G; IN_200],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_199], ExecError> {
+) -> Result<[G; OUT_200], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
@@ -19672,8 +19691,8 @@ fn aiur_fn_199(
         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_199] = [__v_4, __v_8];
-        if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_200] = [__v_4, __v_8];
+        if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19686,7 +19705,7 @@ fn aiur_fn_199(
         let __v_8: G = G::from_u64(2);
         let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         match __v_10.as_canonical_u64() {
@@ -19696,12 +19715,12 @@ fn aiur_fn_199(
             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_199] = [__v_12, __v_16];
-            if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_200] = [__v_12, __v_16];
+            if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             match __v_12.as_canonical_u64() {
@@ -19711,20 +19730,20 @@ fn aiur_fn_199(
                 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_199] = [__v_14, __v_18];
-                if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_200] = [__v_14, __v_18];
+                if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_14: G = G::from_u64(1);
-                let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_13, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { 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_15: G = __r_arr[0];
                 let __v_16: G = (__v_14 - __v_15);
                 let __v_17: G = G::from_u64(1);
-                let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
                 let __v_18: G = __r_arr[0];
-                let __ret: [G; OUT_199] = [__v_17, __v_18];
-                if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_200] = [__v_17, __v_18];
+                if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -19741,15 +19760,15 @@ fn aiur_fn_199(
   })
 }
 
-const INPUT_SIZE_200: usize = 1;
-const IN_200: usize = 1;
-const OUT_200: usize = 2;
-fn aiur_fn_200(
-  inp: [G; IN_200],
+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_200], ExecError> {
+) -> Result<[G; OUT_201], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
@@ -19763,15 +19782,15 @@ fn aiur_fn_200(
         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_200] = [__v_4, __v_8];
-        if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_201] = [__v_4, __v_8];
+        if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
         let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         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 };
@@ -19781,9 +19800,9 @@ fn aiur_fn_200(
         let __v_11: G = __loaded[3];
         match __v_8.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             match __v_13.as_canonical_u64() {
               0u64 => {
@@ -19792,8 +19811,8 @@ fn aiur_fn_200(
                 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_200] = [__v_14, __v_18];
-                if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_201] = [__v_14, __v_18];
+                if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -19808,15 +19827,15 @@ fn aiur_fn_200(
                     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_200] = [__v_17, __v_21];
-                    if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_201] = [__v_17, __v_21];
+                    if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_17: G = G::from_u64(0);
                     let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
                     let __v_18: G = __r_arr[0];
-                    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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 __v_20: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -19826,9 +19845,9 @@ fn aiur_fn_200(
                     let __v_24: G = __loaded[3];
                     match __v_21.as_canonical_u64() {
                       2u64 => {
-                        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
                         let __v_25: G = __r_arr[0];
-                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                         let __v_26: G = __r_arr[0];
                         match __v_26.as_canonical_u64() {
                           0u64 => {
@@ -19837,8 +19856,8 @@ fn aiur_fn_200(
                             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_200] = [__v_27, __v_31];
-                            if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_201] = [__v_27, __v_31];
+                            if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                           _ => {
@@ -19853,8 +19872,8 @@ fn aiur_fn_200(
                                 let __v_32: G = G::from_u64(0);
                                 let __v_33: G = G::from_u64(0);
                                 let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_200] = [__v_30, __v_34];
-                                if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_201] = [__v_30, __v_34];
+                                if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
@@ -19876,11 +19895,11 @@ fn aiur_fn_200(
                                 let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                 let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                 let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } };
                                 let __v_45: G = __r_arr[0];
                                 let __v_46: G = __r_arr[1];
-                                let __ret: [G; OUT_200] = [__v_45, __v_46];
-                                if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_201] = [__v_45, __v_46];
+                                if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -19893,8 +19912,8 @@ fn aiur_fn_200(
                         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_200] = [__v_25, __v_29];
-                        if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_201] = [__v_25, __v_29];
+                        if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
@@ -19909,8 +19928,8 @@ fn aiur_fn_200(
             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_200] = [__v_12, __v_16];
-            if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_201] = [__v_12, __v_16];
+            if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -19919,18 +19938,18 @@ fn aiur_fn_200(
   })
 }
 
-const INPUT_SIZE_201: usize = 1;
-const IN_201: usize = 1;
-const OUT_201: usize = 3;
-fn aiur_fn_201(
-  inp: [G; IN_201],
+const INPUT_SIZE_202: usize = 1;
+const IN_202: usize = 1;
+const OUT_202: usize = 3;
+fn aiur_fn_202(
+  inp: [G; IN_202],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_201], ExecError> {
+) -> Result<[G; OUT_202], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: 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_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -19940,9 +19959,9 @@ fn aiur_fn_201(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
@@ -19959,8 +19978,8 @@ fn aiur_fn_201(
                 let __v_15: G = G::from_u64(1);
                 let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
                 let __v_16: G = __r_arr[0];
-                let __ret: [G; OUT_201] = [__v_12, __v_14, __v_16];
-                if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_202] = [__v_12, __v_14, __v_16];
+                if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -19973,8 +19992,8 @@ fn aiur_fn_201(
                 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_201] = [__v_12, __v_16, __v_20];
-                if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_202] = [__v_12, __v_16, __v_20];
+                if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -19989,8 +20008,8 @@ fn aiur_fn_201(
             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_201] = [__v_9, __v_13, __v_17];
-            if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_202] = [__v_9, __v_13, __v_17];
+            if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -20005,30 +20024,30 @@ fn aiur_fn_201(
         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_201] = [__v_7, __v_11, __v_15];
-        if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_202] = [__v_7, __v_11, __v_15];
+        if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_202: usize = 3;
-const IN_202: usize = 3;
-const OUT_202: usize = 2;
-fn aiur_fn_202(
-  inp: [G; IN_202],
+const INPUT_SIZE_203: usize = 3;
+const IN_203: usize = 3;
+const OUT_203: usize = 2;
+fn aiur_fn_203(
+  inp: [G; IN_203],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_202], ExecError> {
+) -> Result<[G; OUT_203], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
@@ -20043,8 +20062,8 @@ fn aiur_fn_202(
             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_202] = [__v_8, __v_12];
-            if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_203] = [__v_8, __v_12];
+            if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -20056,7 +20075,7 @@ fn aiur_fn_202(
             let __v_11: G = G::from_u64(1);
             let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
             match __v_13.as_canonical_u64() {
@@ -20066,16 +20085,16 @@ fn aiur_fn_202(
                 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_202] = [__v_15, __v_19];
-                if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_203] = [__v_15, __v_19];
+                if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                 let __v_16: G = __r_arr[0];
-                let __ret: [G; OUT_202] = [__v_15, __v_16];
-                if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_203] = [__v_15, __v_16];
+                if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -20086,33 +20105,33 @@ fn aiur_fn_202(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
-            let __ret: [G; OUT_202] = [__v_8, __v_9];
-            if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_203] = [__v_8, __v_9];
+            if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
                 let __v_10: G = __r_arr[1];
-                let __ret: [G; OUT_202] = [__v_9, __v_10];
-                if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_203] = [__v_9, __v_10];
+                if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -20121,8 +20140,8 @@ fn aiur_fn_202(
                 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_202] = [__v_9, __v_13];
-                if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_203] = [__v_9, __v_13];
+                if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -20133,15 +20152,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_204: usize = 2;
+const IN_204: usize = 2;
+const OUT_204: usize = 1;
+fn aiur_fn_204(
+  inp: [G; IN_204],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_203], ExecError> {
+) -> Result<[G; OUT_204], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -20153,8 +20172,8 @@ fn aiur_fn_203(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_203] = [__v_2];
-        if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_204] = [__v_2];
+        if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -20164,8 +20183,8 @@ fn aiur_fn_203(
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_203] = [__v_2];
-            if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_204] = [__v_2];
+            if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
@@ -20175,14 +20194,14 @@ fn aiur_fn_203(
             let __v_11: G = __loaded[2];
             match __v_9.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_203] = [__v_2];
-                if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_204] = [__v_2];
+                if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = G::from_u64(0);
                 let __v_15: G = G::from_u64(0);
@@ -20190,8 +20209,8 @@ fn aiur_fn_203(
                 let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_203] = [__v_19];
-                if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_204] = [__v_19];
+                if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -20211,40 +20230,40 @@ fn aiur_fn_203(
   })
 }
 
-const INPUT_SIZE_204: usize = 2;
-const IN_204: usize = 2;
-const OUT_204: usize = 1;
-fn aiur_fn_204(
-  inp: [G; IN_204],
+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_204], ExecError> {
+) -> Result<[G; OUT_205], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __ret: [G; OUT_204] = [__v_5];
-    if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_205] = [__v_5];
+    if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_205: usize = 0;
-const IN_205: usize = 0;
-const OUT_205: usize = 1;
-fn aiur_fn_205(
-  inp: [G; IN_205],
+const INPUT_SIZE_206: usize = 0;
+const IN_206: usize = 0;
+const OUT_206: usize = 1;
+fn aiur_fn_206(
+  inp: [G; IN_206],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_205], ExecError> {
+) -> Result<[G; OUT_206], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(177);
     let __v_1: G = G::from_u64(246);
@@ -20279,21 +20298,21 @@ fn aiur_fn_205(
     let __v_30: G = G::from_u64(17);
     let __v_31: G = G::from_u64(5);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_205] = [__v_32];
-    if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_206] = [__v_32];
+    if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_206: usize = 0;
-const IN_206: usize = 0;
-const OUT_206: usize = 1;
-fn aiur_fn_206(
-  inp: [G; IN_206],
+const INPUT_SIZE_207: usize = 0;
+const IN_207: usize = 0;
+const OUT_207: usize = 1;
+fn aiur_fn_207(
+  inp: [G; IN_207],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_206], ExecError> {
+) -> Result<[G; OUT_207], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(182);
     let __v_1: G = G::from_u64(236);
@@ -20328,21 +20347,21 @@ fn aiur_fn_206(
     let __v_30: G = G::from_u64(113);
     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_206] = [__v_32];
-    if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_207] = [__v_32];
+    if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_207: usize = 0;
-const IN_207: usize = 0;
-const OUT_207: usize = 1;
-fn aiur_fn_207(
-  inp: [G; IN_207],
+const INPUT_SIZE_208: usize = 0;
+const IN_208: usize = 0;
+const OUT_208: usize = 1;
+fn aiur_fn_208(
+  inp: [G; IN_208],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_207], ExecError> {
+) -> Result<[G; OUT_208], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(213);
     let __v_1: G = G::from_u64(77);
@@ -20377,21 +20396,21 @@ fn aiur_fn_207(
     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_207] = [__v_32];
-    if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_208] = [__v_32];
+    if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_208: usize = 0;
-const IN_208: usize = 0;
-const OUT_208: usize = 1;
-fn aiur_fn_208(
-  inp: [G; IN_208],
+const INPUT_SIZE_209: usize = 0;
+const IN_209: usize = 0;
+const OUT_209: usize = 1;
+fn aiur_fn_209(
+  inp: [G; IN_209],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_208], ExecError> {
+) -> Result<[G; OUT_209], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(41);
     let __v_1: G = G::from_u64(86);
@@ -20426,21 +20445,21 @@ fn aiur_fn_208(
     let __v_30: G = G::from_u64(107);
     let __v_31: G = G::from_u64(42);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_208] = [__v_32];
-    if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_209] = [__v_32];
+    if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_209: usize = 0;
-const IN_209: usize = 0;
-const OUT_209: usize = 1;
-fn aiur_fn_209(
-  inp: [G; IN_209],
+const INPUT_SIZE_210: usize = 0;
+const IN_210: usize = 0;
+const OUT_210: usize = 1;
+fn aiur_fn_210(
+  inp: [G; IN_210],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_209], ExecError> {
+) -> Result<[G; OUT_210], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(60);
     let __v_1: G = G::from_u64(1);
@@ -20475,21 +20494,21 @@ fn aiur_fn_209(
     let __v_30: G = G::from_u64(44);
     let __v_31: G = G::from_u64(66);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_209] = [__v_32];
-    if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_210] = [__v_32];
+    if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_210: usize = 0;
-const IN_210: usize = 0;
-const OUT_210: usize = 1;
-fn aiur_fn_210(
-  inp: [G; IN_210],
+const INPUT_SIZE_211: usize = 0;
+const IN_211: usize = 0;
+const OUT_211: usize = 1;
+fn aiur_fn_211(
+  inp: [G; IN_211],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_210], ExecError> {
+) -> Result<[G; OUT_211], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(209);
     let __v_1: G = G::from_u64(224);
@@ -20524,21 +20543,21 @@ fn aiur_fn_210(
     let __v_30: G = G::from_u64(136);
     let __v_31: G = G::from_u64(196);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_210] = [__v_32];
-    if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_211] = [__v_32];
+    if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_211: usize = 0;
-const IN_211: usize = 0;
-const OUT_211: usize = 1;
-fn aiur_fn_211(
-  inp: [G; IN_211],
+const INPUT_SIZE_212: usize = 0;
+const IN_212: usize = 0;
+const OUT_212: usize = 1;
+fn aiur_fn_212(
+  inp: [G; IN_212],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_211], ExecError> {
+) -> Result<[G; OUT_212], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(213);
     let __v_1: G = G::from_u64(84);
@@ -20573,21 +20592,21 @@ fn aiur_fn_211(
     let __v_30: G = G::from_u64(199);
     let __v_31: G = G::from_u64(137);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_211] = [__v_32];
-    if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_212] = [__v_32];
+    if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_212: usize = 0;
-const IN_212: usize = 0;
-const OUT_212: usize = 1;
-fn aiur_fn_212(
-  inp: [G; IN_212],
+const INPUT_SIZE_213: usize = 0;
+const IN_213: usize = 0;
+const OUT_213: usize = 1;
+fn aiur_fn_213(
+  inp: [G; IN_213],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_212], ExecError> {
+) -> Result<[G; OUT_213], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(63);
     let __v_1: G = G::from_u64(146);
@@ -20622,21 +20641,21 @@ fn aiur_fn_212(
     let __v_30: G = G::from_u64(11);
     let __v_31: G = G::from_u64(107);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_212] = [__v_32];
-    if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_213] = [__v_32];
+    if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_213: usize = 0;
-const IN_213: usize = 0;
-const OUT_213: usize = 1;
-fn aiur_fn_213(
-  inp: [G; IN_213],
+const INPUT_SIZE_214: usize = 0;
+const IN_214: usize = 0;
+const OUT_214: usize = 1;
+fn aiur_fn_214(
+  inp: [G; IN_214],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_213], ExecError> {
+) -> Result<[G; OUT_214], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(162);
     let __v_1: G = G::from_u64(163);
@@ -20671,21 +20690,21 @@ fn aiur_fn_213(
     let __v_30: G = G::from_u64(223);
     let __v_31: G = G::from_u64(102);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_213] = [__v_32];
-    if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_214] = [__v_32];
+    if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_214: usize = 0;
-const IN_214: usize = 0;
-const OUT_214: usize = 1;
-fn aiur_fn_214(
-  inp: [G; IN_214],
+const INPUT_SIZE_215: usize = 0;
+const IN_215: usize = 0;
+const OUT_215: usize = 1;
+fn aiur_fn_215(
+  inp: [G; IN_215],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_214], ExecError> {
+) -> Result<[G; OUT_215], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(173);
     let __v_1: G = G::from_u64(112);
@@ -20720,21 +20739,21 @@ fn aiur_fn_214(
     let __v_30: G = G::from_u64(235);
     let __v_31: G = G::from_u64(156);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_32];
-    if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_215] = [__v_32];
+    if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_215: usize = 0;
-const IN_215: usize = 0;
-const OUT_215: usize = 1;
-fn aiur_fn_215(
-  inp: [G; IN_215],
+const INPUT_SIZE_216: usize = 0;
+const IN_216: usize = 0;
+const OUT_216: usize = 1;
+fn aiur_fn_216(
+  inp: [G; IN_216],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_215], ExecError> {
+) -> Result<[G; OUT_216], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(216);
     let __v_1: G = G::from_u64(56);
@@ -20769,21 +20788,21 @@ fn aiur_fn_215(
     let __v_30: G = G::from_u64(83);
     let __v_31: G = G::from_u64(8);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_215] = [__v_32];
-    if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_216] = [__v_32];
+    if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_216: usize = 0;
-const IN_216: usize = 0;
-const OUT_216: usize = 1;
-fn aiur_fn_216(
-  inp: [G; IN_216],
+const INPUT_SIZE_217: usize = 0;
+const IN_217: usize = 0;
+const OUT_217: usize = 1;
+fn aiur_fn_217(
+  inp: [G; IN_217],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_216], ExecError> {
+) -> Result<[G; OUT_217], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(214);
     let __v_1: G = G::from_u64(22);
@@ -20818,21 +20837,21 @@ fn aiur_fn_216(
     let __v_30: G = G::from_u64(251);
     let __v_31: G = G::from_u64(119);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_216] = [__v_32];
-    if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_217] = [__v_32];
+    if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_217: usize = 0;
-const IN_217: usize = 0;
-const OUT_217: usize = 1;
-fn aiur_fn_217(
-  inp: [G; IN_217],
+const INPUT_SIZE_218: usize = 0;
+const IN_218: usize = 0;
+const OUT_218: usize = 1;
+fn aiur_fn_218(
+  inp: [G; IN_218],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_217], ExecError> {
+) -> Result<[G; OUT_218], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(66);
     let __v_1: G = G::from_u64(136);
@@ -20867,110 +20886,110 @@ fn aiur_fn_217(
     let __v_30: G = G::from_u64(159);
     let __v_31: G = G::from_u64(173);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_217] = [__v_32];
-    if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_218] = [__v_32];
+    if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_218: usize = 1;
-const IN_218: usize = 1;
-const OUT_218: usize = 1;
-fn aiur_fn_218(
-  inp: [G; IN_218],
+const INPUT_SIZE_219: usize = 1;
+const IN_219: usize = 1;
+const OUT_219: usize = 1;
+fn aiur_fn_219(
+  inp: [G; IN_219],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_218], ExecError> {
+) -> Result<[G; OUT_219], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_218] = [__v_3];
-        if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_219] = [__v_3];
+        if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_218] = [__v_5];
-            if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_219] = [__v_5];
+            if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             match __v_6.as_canonical_u64() {
               1u64 => {
                 let __v_7: G = G::from_u64(1);
-                let __ret: [G; OUT_218] = [__v_7];
-                if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_219] = [__v_7];
+                if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_8: G = __r_arr[0];
                 match __v_8.as_canonical_u64() {
                   1u64 => {
                     let __v_9: G = G::from_u64(1);
-                    let __ret: [G; OUT_218] = [__v_9];
-                    if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_219] = [__v_9];
+                    if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
                     let __v_9: G = __r_arr[0];
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
                     match __v_10.as_canonical_u64() {
                       1u64 => {
                         let __v_11: G = G::from_u64(1);
-                        let __ret: [G; OUT_218] = [__v_11];
-                        if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_219] = [__v_11];
+                        if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } };
                         let __v_11: G = __r_arr[0];
-                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                         let __v_12: G = __r_arr[0];
                         match __v_12.as_canonical_u64() {
                           1u64 => {
                             let __v_13: G = G::from_u64(1);
-                            let __ret: [G; OUT_218] = [__v_13];
-                            if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_219] = [__v_13];
+                            if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
                             let __v_13: G = __r_arr[0];
-                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                             let __v_14: G = __r_arr[0];
                             match __v_14.as_canonical_u64() {
                               1u64 => {
                                 let __v_15: G = G::from_u64(1);
-                                let __ret: [G; OUT_218] = [__v_15];
-                                if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_219] = [__v_15];
+                                if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_15: G = G::from_u64(0);
-                                let __ret: [G; OUT_218] = [__v_15];
-                                if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_219] = [__v_15];
+                                if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -20989,24 +21008,24 @@ fn aiur_fn_218(
   })
 }
 
-const INPUT_SIZE_219: usize = 3;
-const IN_219: usize = 3;
-const OUT_219: usize = 2;
-fn aiur_fn_219(
-  inp: [G; IN_219],
+const INPUT_SIZE_220: usize = 3;
+const IN_220: usize = 3;
+const OUT_220: usize = 2;
+fn aiur_fn_220(
+  inp: [G; IN_220],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_219], ExecError> {
+) -> Result<[G; OUT_220], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       1u64 => {
@@ -21015,7 +21034,7 @@ fn aiur_fn_219(
             let __v_6: G = G::from_u64(0);
             let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             match __v_8.as_canonical_u64() {
@@ -21025,8 +21044,8 @@ fn aiur_fn_219(
                 let __v_12: G = G::from_u64(1);
                 let __v_13: G = G::from_u64(0);
                 let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_219] = [__v_10, __v_14];
-                if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_220] = [__v_10, __v_14];
+                if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               0u64 => {
@@ -21035,8 +21054,8 @@ fn aiur_fn_219(
                 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_219] = [__v_10, __v_14];
-                if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_220] = [__v_10, __v_14];
+                if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -21050,16 +21069,16 @@ fn aiur_fn_219(
             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_219] = [__v_6, __v_10];
-            if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_220] = [__v_6, __v_10];
+            if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
@@ -21072,8 +21091,8 @@ fn aiur_fn_219(
                 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_219] = [__v_10, __v_14];
-                if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_220] = [__v_10, __v_14];
+                if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -21091,15 +21110,15 @@ fn aiur_fn_219(
                       1u64 => {
                         let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
                         let __v_16: G = __r_arr[0];
-                        let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } };
                         let __v_17: G = __r_arr[0];
                         let __v_18: G = G::from_u64(1);
                         let __v_19: G = G::from_u64(7);
                         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_17, __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_219] = [__v_18, __v_22];
-                        if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_220] = [__v_18, __v_22];
+                        if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       _ => {
@@ -21108,8 +21127,8 @@ fn aiur_fn_219(
                         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_219] = [__v_16, __v_20];
-                        if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_220] = [__v_16, __v_20];
+                        if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
@@ -21120,8 +21139,8 @@ fn aiur_fn_219(
                     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_219] = [__v_16, __v_20];
-                    if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_220] = [__v_16, __v_20];
+                    if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
@@ -21129,65 +21148,65 @@ fn aiur_fn_219(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
                 let __v_11: G = __r_arr[1];
-                let __ret: [G; OUT_219] = [__v_10, __v_11];
-                if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_220] = [__v_10, __v_11];
+                if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
                     let __v_13: G = __r_arr[1];
-                    let __ret: [G; OUT_219] = [__v_12, __v_13];
-                    if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_220] = [__v_12, __v_13];
+                    if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_13: G = __r_arr[0];
                     match __v_13.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } };
                         let __v_14: G = __r_arr[0];
                         let __v_15: G = __r_arr[1];
-                        let __ret: [G; OUT_219] = [__v_14, __v_15];
-                        if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_220] = [__v_14, __v_15];
+                        if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
                         let __v_14: G = __r_arr[0];
-                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                         let __v_15: G = __r_arr[0];
                         match __v_15.as_canonical_u64() {
                           1u64 => {
                             let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
                             let __v_16: G = __r_arr[0];
                             let __v_17: G = __r_arr[1];
-                            let __ret: [G; OUT_219] = [__v_16, __v_17];
-                            if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_220] = [__v_16, __v_17];
+                            if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
                             let __v_16: G = __r_arr[0];
-                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                             let __v_17: G = __r_arr[0];
                             match __v_17.as_canonical_u64() {
                               1u64 => {
@@ -21200,8 +21219,8 @@ fn aiur_fn_219(
                                     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_219] = [__v_20, __v_24];
-                                    if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_220] = [__v_20, __v_24];
+                                    if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -21236,8 +21255,8 @@ fn aiur_fn_219(
                                                     let __v_35: G = G::from_u64(1);
                                                     let __v_36: G = G::from_u64(0);
                                                     let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                    let __ret: [G; OUT_219] = [__v_33, __v_37];
-                                                    if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                    let __ret: [G; OUT_220] = [__v_33, __v_37];
+                                                    if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
@@ -21246,8 +21265,8 @@ fn aiur_fn_219(
                                                     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_219] = [__v_32, __v_36];
-                                                    if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                    let __ret: [G; OUT_220] = [__v_32, __v_36];
+                                                    if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                     return Ok(__ret);
                                                   },
                                                 }
@@ -21258,8 +21277,8 @@ fn aiur_fn_219(
                                                 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_219] = [__v_32, __v_36];
-                                                if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                let __ret: [G; OUT_220] = [__v_32, __v_36];
+                                                if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                 return Ok(__ret);
                                               },
                                             }
@@ -21270,8 +21289,8 @@ fn aiur_fn_219(
                                             let __v_30: G = G::from_u64(0);
                                             let __v_31: G = G::from_u64(0);
                                             let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_219] = [__v_28, __v_32];
-                                            if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            let __ret: [G; OUT_220] = [__v_28, __v_32];
+                                            if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                             return Ok(__ret);
                                           },
                                         }
@@ -21282,8 +21301,8 @@ fn aiur_fn_219(
                                         let __v_30: G = G::from_u64(0);
                                         let __v_31: G = G::from_u64(0);
                                         let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __ret: [G; OUT_219] = [__v_28, __v_32];
-                                        if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        let __ret: [G; OUT_220] = [__v_28, __v_32];
+                                        if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                         return Ok(__ret);
                                       },
                                     }
@@ -21296,8 +21315,8 @@ fn aiur_fn_219(
                                 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_219] = [__v_18, __v_22];
-                                if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_220] = [__v_18, __v_22];
+                                if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -21316,15 +21335,15 @@ fn aiur_fn_219(
   })
 }
 
-const INPUT_SIZE_220: usize = 1;
-const IN_220: usize = 1;
-const OUT_220: usize = 2;
-fn aiur_fn_220(
-  inp: [G; IN_220],
+const INPUT_SIZE_221: usize = 1;
+const IN_221: usize = 1;
+const OUT_221: usize = 2;
+fn aiur_fn_221(
+  inp: [G; IN_221],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_220], ExecError> {
+) -> Result<[G; OUT_221], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
@@ -21338,8 +21357,8 @@ fn aiur_fn_220(
         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_220] = [__v_4, __v_8];
-        if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_221] = [__v_4, __v_8];
+        if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -21355,16 +21374,16 @@ fn aiur_fn_220(
           7u64 => {
             match __v_7.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 let __v_12: G = G::from_u64(7);
                 let __v_13: G = G::from_u64(0);
                 let __v_14: G = G::from_u64(0);
                 let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_16: G = G::from_u64(2);
-                let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
                 let __v_17: G = __r_arr[0];
                 let __v_18: G = G::from_u64(1);
                 let __v_19: G = G::from_u64(1);
@@ -21375,8 +21394,8 @@ fn aiur_fn_220(
                 let __v_24: G = G::from_u64(3);
                 let __v_25: G = G::from_u64(0);
                 let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_220] = [__v_23, __v_26];
-                if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_221] = [__v_23, __v_26];
+                if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -21385,8 +21404,8 @@ fn aiur_fn_220(
                 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_220] = [__v_10, __v_14];
-                if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_221] = [__v_10, __v_14];
+                if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -21397,8 +21416,8 @@ fn aiur_fn_220(
             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_220] = [__v_10, __v_14];
-            if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_221] = [__v_10, __v_14];
+            if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -21407,15 +21426,15 @@ fn aiur_fn_220(
   })
 }
 
-const INPUT_SIZE_221: usize = 1;
-const IN_221: usize = 1;
-const OUT_221: usize = 2;
-fn aiur_fn_221(
-  inp: [G; IN_221],
+const INPUT_SIZE_222: usize = 1;
+const IN_222: usize = 1;
+const OUT_222: usize = 2;
+fn aiur_fn_222(
+  inp: [G; IN_222],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_221], ExecError> {
+) -> Result<[G; OUT_222], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
@@ -21429,8 +21448,8 @@ fn aiur_fn_221(
         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_221] = [__v_4, __v_8];
-        if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_222] = [__v_4, __v_8];
+        if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -21454,15 +21473,15 @@ fn aiur_fn_221(
                   1u64 => {
                     let __v_13: G = G::from_u64(1);
                     let __v_14: G = G::from_u64(2);
-                    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
                     let __v_15: G = __r_arr[0];
                     let __v_16: G = G::from_u64(1);
                     let __v_17: G = G::from_u64(1);
                     let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                     let __v_19: G = G::from_u64(0);
                     let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_221] = [__v_13, __v_20];
-                    if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_222] = [__v_13, __v_20];
+                    if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -21471,8 +21490,8 @@ fn aiur_fn_221(
                     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_221] = [__v_13, __v_17];
-                    if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_222] = [__v_13, __v_17];
+                    if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
@@ -21483,8 +21502,8 @@ fn aiur_fn_221(
                 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_221] = [__v_10, __v_14];
-                if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_222] = [__v_10, __v_14];
+                if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -21495,8 +21514,8 @@ fn aiur_fn_221(
             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_221] = [__v_10, __v_14];
-            if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_222] = [__v_10, __v_14];
+            if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -21505,15 +21524,15 @@ fn aiur_fn_221(
   })
 }
 
-const INPUT_SIZE_222: usize = 1;
-const IN_222: usize = 1;
-const OUT_222: usize = 0;
-fn aiur_fn_222(
-  inp: [G; IN_222],
+const INPUT_SIZE_223: usize = 1;
+const IN_223: usize = 1;
+const OUT_223: usize = 0;
+fn aiur_fn_223(
+  inp: [G; IN_223],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_222], ExecError> {
+) -> Result<[G; OUT_223], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -21522,17 +21541,17 @@ fn aiur_fn_222(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_222] = [];
-        if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_223] = [];
+        if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
-        let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_222] = [];
-        if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_223] = [];
+        if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -21542,35 +21561,35 @@ 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_224: usize = 1;
+const IN_224: usize = 1;
+const OUT_224: usize = 1;
+fn aiur_fn_224(
+  inp: [G; IN_224],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_223], ExecError> {
+) -> Result<[G; OUT_224], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(65);
-    let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __ret: [G; OUT_223] = [__v_2];
-    if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_224] = [__v_2];
+    if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_224: usize = 2;
-const IN_224: usize = 2;
-const OUT_224: usize = 1;
-fn aiur_fn_224(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_224], 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];
@@ -21580,18 +21599,18 @@ fn aiur_fn_224(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_224] = [__v_1];
-        if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_225] = [__v_1];
+        if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_224] = [__v_7];
-        if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_225] = [__v_7];
+        if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -21601,15 +21620,15 @@ fn aiur_fn_224(
   })
 }
 
-const INPUT_SIZE_225: usize = 1;
-const IN_225: usize = 1;
-const OUT_225: usize = 1;
-fn aiur_fn_225(
-  inp: [G; IN_225],
+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_225], ExecError> {
+) -> Result<[G; OUT_226], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(128);
@@ -21622,8 +21641,8 @@ fn aiur_fn_225(
           1u64 => {
             let __v_5: G = G::from_u64(128);
             let __v_6: G = (__v_0 - __v_5);
-            let __ret: [G; OUT_225] = [__v_6];
-            if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_226] = [__v_6];
+            if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -21638,15 +21657,15 @@ fn aiur_fn_225(
   })
 }
 
-const INPUT_SIZE_226: usize = 2;
-const IN_226: usize = 2;
-const OUT_226: usize = 2;
-fn aiur_fn_226(
-  inp: [G; IN_226],
+const INPUT_SIZE_227: usize = 2;
+const IN_227: usize = 2;
+const OUT_227: usize = 2;
+fn aiur_fn_227(
+  inp: [G; IN_227],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_226], 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];
@@ -21654,8 +21673,8 @@ fn aiur_fn_226(
     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_226] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_227] = [__v_0, __v_1];
+        if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -21677,11 +21696,11 @@ fn aiur_fn_226(
                     let __v_12: G = (__v_0 - __v_11);
                     let __v_13: G = G::from_u64(64);
                     let __v_14: G = (__v_12 * __v_13);
-                    let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
                     let __v_15: G = __r_arr[0];
                     let __v_16: G = (__v_14 + __v_15);
-                    let __ret: [G; OUT_226] = [__v_16, __v_10];
-                    if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_227] = [__v_16, __v_10];
+                    if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -21710,11 +21729,11 @@ fn aiur_fn_226(
                             let __v_17: G = (__v_0 - __v_16);
                             let __v_18: G = G::from_u64(4096);
                             let __v_19: G = (__v_17 * __v_18);
-                            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
                             let __v_20: G = __r_arr[0];
                             let __v_21: G = G::from_u64(64);
                             let __v_22: G = (__v_20 * __v_21);
-                            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
                             let __v_23: G = __r_arr[0];
                             let __v_24: G = (__v_22 + __v_23);
                             let __v_25: G = (__v_19 + __v_24);
@@ -21722,8 +21741,8 @@ fn aiur_fn_226(
                             let __v_27: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_26.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
                             match __v_27.as_canonical_u64() {
                               0u64 => {
-                                let __ret: [G; OUT_226] = [__v_25, __v_15];
-                                if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_227] = [__v_25, __v_15];
+                                if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
@@ -21764,15 +21783,15 @@ fn aiur_fn_226(
                                 let __v_20: G = (__v_0 - __v_19);
                                 let __v_21: G = G::from_u64(262144);
                                 let __v_22: G = (__v_20 * __v_21);
-                                let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
                                 let __v_23: G = __r_arr[0];
                                 let __v_24: G = G::from_u64(4096);
                                 let __v_25: G = (__v_23 * __v_24);
-                                let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
                                 let __v_26: G = __r_arr[0];
                                 let __v_27: G = G::from_u64(64);
                                 let __v_28: G = (__v_26 * __v_27);
-                                let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
                                 let __v_29: G = __r_arr[0];
                                 let __v_30: G = (__v_28 + __v_29);
                                 let __v_31: G = (__v_25 + __v_30);
@@ -21781,8 +21800,8 @@ fn aiur_fn_226(
                                 let __v_34: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_33.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
                                 match __v_34.as_canonical_u64() {
                                   0u64 => {
-                                    let __ret: [G; OUT_226] = [__v_32, __v_18];
-                                    if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_227] = [__v_32, __v_18];
+                                    if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -21818,15 +21837,15 @@ fn aiur_fn_226(
   })
 }
 
-const INPUT_SIZE_227: usize = 1;
-const IN_227: usize = 1;
-const OUT_227: usize = 1;
-fn aiur_fn_227(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_227], ExecError> {
+) -> Result<[G; OUT_228], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -21838,17 +21857,17 @@ fn aiur_fn_227(
     let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_9: G = G::from_u64(2);
-    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = G::from_u64(0);
     let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_13: G = G::from_u64(2);
-    let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
     let __v_15: G = G::from_u64(0);
     let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_17: G = G::from_u64(2);
-    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
     let __v_19: G = G::from_u64(1);
     let __v_20: G = G::from_u64(1);
@@ -21856,7 +21875,7 @@ fn aiur_fn_227(
     let __v_22: G = G::from_u64(0);
     let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_24: G = G::from_u64(2);
-    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
     let __v_25: G = __r_arr[0];
     let __v_26: G = G::from_u64(1);
     let __v_27: G = G::from_u64(1);
@@ -21864,7 +21883,7 @@ fn aiur_fn_227(
     let __v_29: G = G::from_u64(0);
     let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_31: G = G::from_u64(2);
-    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
     let __v_32: G = __r_arr[0];
     let __v_33: G = G::from_u64(1);
     let __v_34: G = G::from_u64(1);
@@ -21877,26 +21896,26 @@ fn aiur_fn_227(
     let __v_41: G = G::from_u64(3);
     let __v_42: G = G::from_u64(0);
     let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
     let __v_44: G = __r_arr[0];
     let __v_45: G = G::from_u64(3);
     let __v_46: G = G::from_u64(0);
     let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_227] = [__v_47];
-    if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_228] = [__v_47];
+    if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_228: usize = 4;
-const IN_228: usize = 4;
-const OUT_228: usize = 1;
-fn aiur_fn_228(
-  inp: [G; IN_228],
+const INPUT_SIZE_229: usize = 4;
+const IN_229: usize = 4;
+const OUT_229: usize = 1;
+fn aiur_fn_229(
+  inp: [G; IN_229],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_228], 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];
@@ -21908,15 +21927,15 @@ fn aiur_fn_228(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_228] = [__v_1];
-        if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_229] = [__v_1];
+        if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(7);
         let __v_11: G = G::from_u64(0);
@@ -21928,13 +21947,13 @@ fn aiur_fn_228(
         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_228] = { let __args: [G; IN_228] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __v_21: G = G::from_u64(3);
         let __v_22: G = G::from_u64(0);
         let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_228] = [__v_23];
-        if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_229] = [__v_23];
+        if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -21944,15 +21963,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_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_229], 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];
@@ -21970,7 +21989,7 @@ fn aiur_fn_229(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_11: G = __loaded[0];
@@ -21990,7 +22009,7 @@ fn aiur_fn_229(
                 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_335] = { let __args: [G; IN_335] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
                 let __v_26: G = __r_arr[0];
                 let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                 let __v_27: G = __loaded[0];
@@ -22004,8 +22023,8 @@ fn aiur_fn_229(
                     let __v_32: G = __r_arr[0];
                     let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
                     let __v_33: G = __r_arr[0];
-                    let __ret: [G; OUT_229] = [__v_33];
-                    if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_230] = [__v_33];
+                    if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -22014,44 +22033,44 @@ fn aiur_fn_229(
                     let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                     let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
                     let __v_34: G = __r_arr[0];
-                    let __ret: [G; OUT_229] = [__v_34];
-                    if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_230] = [__v_34];
+                    if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_229] = [__v_0];
-                if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_230] = [__v_0];
+                if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_229] = [__v_0];
-            if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_230] = [__v_0];
+            if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __ret: [G; OUT_229] = [__v_0];
-        if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_230] = [__v_0];
+        if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_230: usize = 2;
-const IN_230: usize = 2;
-const OUT_230: usize = 1;
-fn aiur_fn_230(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_230], ExecError> {
+) -> Result<[G; OUT_231], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22064,75 +22083,75 @@ fn aiur_fn_230(
       7u64 => {
         match __v_3.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_230] = [__v_7];
-            if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_231] = [__v_7];
+            if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_230] = [__v_0];
-            if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_231] = [__v_0];
+            if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __ret: [G; OUT_230] = [__v_0];
-        if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_231] = [__v_0];
+        if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_231: usize = 1;
-const IN_231: usize = 1;
-const OUT_231: usize = 4;
-fn aiur_fn_231(
-  inp: [G; IN_231],
+const INPUT_SIZE_232: usize = 1;
+const IN_232: usize = 1;
+const OUT_232: usize = 4;
+fn aiur_fn_232(
+  inp: [G; IN_232],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_231], ExecError> {
+) -> Result<[G; OUT_232], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
-    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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_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_125] = { let __args: [G; IN_125] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_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_125] = { let __args: [G; IN_125] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_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_125] = { let __args: [G; IN_125] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __ret: [G; OUT_231] = [__v_2, __v_5, __v_8, __v_11];
-    if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_232] = [__v_2, __v_5, __v_8, __v_11];
+    if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_232: usize = 1;
-const IN_232: usize = 1;
-const OUT_232: usize = 1;
-fn aiur_fn_232(
-  inp: [G; IN_232],
+const INPUT_SIZE_233: usize = 1;
+const IN_233: usize = 1;
+const OUT_233: usize = 1;
+fn aiur_fn_233(
+  inp: [G; IN_233],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_232], ExecError> {
+) -> Result<[G; OUT_233], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { 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_232] = { let __args: [G; IN_232] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -22166,29 +22185,29 @@ fn aiur_fn_232(
     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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
     let __v_31: G = __r_arr[0];
-    let __ret: [G; OUT_232] = [__v_31];
-    if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_233] = [__v_31];
+    if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_233: usize = 2;
-const IN_233: usize = 2;
-const OUT_233: usize = 2;
-fn aiur_fn_233(
-  inp: [G; IN_233],
+const INPUT_SIZE_234: usize = 2;
+const IN_234: usize = 2;
+const OUT_234: usize = 2;
+fn aiur_fn_234(
+  inp: [G; IN_234],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_233], ExecError> {
+) -> Result<[G; OUT_234], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: 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_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -22198,9 +22217,9 @@ fn aiur_fn_233(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         match __v_10.as_canonical_u64() {
           1u64 => {
@@ -22212,8 +22231,8 @@ fn aiur_fn_233(
                 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_233] = [__v_12, __v_15];
-                if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_234] = [__v_12, __v_15];
+                if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -22221,16 +22240,16 @@ fn aiur_fn_233(
                 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_233] = [__v_12, __v_15];
-                if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_234] = [__v_12, __v_15];
+                if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             match __v_12.as_canonical_u64() {
               0u64 => {
@@ -22238,8 +22257,8 @@ fn aiur_fn_233(
                 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_233] = [__v_13, __v_16];
-                if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_234] = [__v_13, __v_16];
+                if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -22250,7 +22269,7 @@ fn aiur_fn_233(
                     let __v_14: G = G::from_u64(1);
                     let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
                     let __v_15: G = __r_arr[0];
-                    let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
                     let __v_16: G = __r_arr[0];
                     let __v_17: G = __r_arr[1];
                     match __v_16.as_canonical_u64() {
@@ -22259,30 +22278,30 @@ fn aiur_fn_233(
                         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_233] = [__v_18, __v_21];
-                        if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_234] = [__v_18, __v_21];
+                        if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       1u64 => {
                         let __v_18: G = G::from_u64(2);
                         let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
                         let __v_19: G = __r_arr[0];
-                        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } };
                         let __v_20: G = __r_arr[0];
                         let __v_21: G = __r_arr[1];
                         match __v_20.as_canonical_u64() {
                           0u64 => {
                             let __v_22: G = G::from_u64(0);
-                            let __ret: [G; OUT_233] = [__v_22, __v_21];
-                            if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_234] = [__v_22, __v_21];
+                            if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                           1u64 => {
                             let __v_22: G = G::from_u64(1);
-                            let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } };
                             let __v_23: G = __r_arr[0];
-                            let __ret: [G; OUT_233] = [__v_22, __v_23];
-                            if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_234] = [__v_22, __v_23];
+                            if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                           _ => {
@@ -22300,8 +22319,8 @@ fn aiur_fn_233(
                     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_233] = [__v_14, __v_17];
-                    if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_234] = [__v_14, __v_17];
+                    if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
@@ -22315,59 +22334,59 @@ fn aiur_fn_233(
         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_233] = [__v_9, __v_12];
-        if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_234] = [__v_9, __v_12];
+        if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_234: usize = 2;
-const IN_234: usize = 2;
-const OUT_234: usize = 2;
-fn aiur_fn_234(
-  inp: [G; IN_234],
+const INPUT_SIZE_235: usize = 2;
+const IN_235: usize = 2;
+const OUT_235: usize = 2;
+fn aiur_fn_235(
+  inp: [G; IN_235],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_234], ExecError> {
+) -> Result<[G; OUT_235], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_234] = [__v_4, __v_3];
-        if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_235] = [__v_4, __v_3];
+        if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_234] = [__v_5, __v_6];
-        if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_235] = [__v_5, __v_6];
+        if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_235: usize = 1;
-const IN_235: usize = 1;
-const OUT_235: usize = 2;
-fn aiur_fn_235(
-  inp: [G; IN_235],
+const INPUT_SIZE_236: usize = 1;
+const IN_236: usize = 1;
+const OUT_236: usize = 2;
+fn aiur_fn_236(
+  inp: [G; IN_236],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_235], ExecError> {
+) -> Result<[G; OUT_236], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -22384,16 +22403,16 @@ fn aiur_fn_235(
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               0u64 => {
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_235] = [__v_11, __v_12];
-                if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_236] = [__v_11, __v_12];
+                if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -22406,18 +22425,18 @@ fn aiur_fn_235(
                   7u64 => {
                     match __v_12.as_canonical_u64() {
                       0u64 => {
-                        let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
                         let __v_15: G = __r_arr[0];
                         let __v_16: G = __r_arr[1];
-                        let __ret: [G; OUT_235] = [__v_15, __v_16];
-                        if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_236] = [__v_15, __v_16];
+                        if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_15: G = G::from_u64(0);
                         let __v_16: G = G::from_u64(0);
-                        let __ret: [G; OUT_235] = [__v_15, __v_16];
-                        if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_236] = [__v_15, __v_16];
+                        if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
@@ -22425,8 +22444,8 @@ fn aiur_fn_235(
                   _ => {
                     let __v_15: G = G::from_u64(0);
                     let __v_16: G = G::from_u64(0);
-                    let __ret: [G; OUT_235] = [__v_15, __v_16];
-                    if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_236] = [__v_15, __v_16];
+                    if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
@@ -22436,8 +22455,8 @@ fn aiur_fn_235(
           _ => {
             let __v_9: G = G::from_u64(0);
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_235] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_236] = [__v_9, __v_10];
+            if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -22445,23 +22464,23 @@ fn aiur_fn_235(
       _ => {
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_235] = [__v_5, __v_6];
-        if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_236] = [__v_5, __v_6];
+        if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_236: usize = 1;
-const IN_236: usize = 1;
-const OUT_236: usize = 2;
-fn aiur_fn_236(
-  inp: [G; IN_236],
+const INPUT_SIZE_237: usize = 1;
+const IN_237: usize = 1;
+const OUT_237: usize = 2;
+fn aiur_fn_237(
+  inp: [G; IN_237],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_236], ExecError> {
+) -> Result<[G; OUT_237], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
@@ -22499,8 +22518,8 @@ fn aiur_fn_236(
               0u64 => {
                 let __v_26: G = G::from_u64(0);
                 let __v_27: G = G::from_u64(0);
-                let __ret: [G; OUT_236] = [__v_26, __v_27];
-                if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_237] = [__v_26, __v_27];
+                if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -22515,8 +22534,8 @@ fn aiur_fn_236(
                 match __v_33.as_canonical_u64() {
                   1u64 => {
                     let __v_34: G = G::from_u64(1);
-                    let __ret: [G; OUT_236] = [__v_34, __v_31];
-                    if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_237] = [__v_34, __v_31];
+                    if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -22526,8 +22545,8 @@ fn aiur_fn_236(
                       0u64 => {
                         let __v_36: G = G::from_u64(0);
                         let __v_37: G = G::from_u64(0);
-                        let __ret: [G; OUT_236] = [__v_36, __v_37];
-                        if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_237] = [__v_36, __v_37];
+                        if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       _ => {
@@ -22536,15 +22555,15 @@ fn aiur_fn_236(
                         match __v_37.as_canonical_u64() {
                           1u64 => {
                             let __v_38: G = G::from_u64(1);
-                            let __ret: [G; OUT_236] = [__v_38, __v_31];
-                            if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_237] = [__v_38, __v_31];
+                            if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_38: G = G::from_u64(0);
                             let __v_39: G = G::from_u64(0);
-                            let __ret: [G; OUT_236] = [__v_38, __v_39];
-                            if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_237] = [__v_38, __v_39];
+                            if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                         }
@@ -22558,8 +22577,8 @@ fn aiur_fn_236(
           _ => {
             let __v_21: G = G::from_u64(0);
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_236] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_237] = [__v_21, __v_22];
+            if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -22567,23 +22586,23 @@ fn aiur_fn_236(
       _ => {
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_236] = [__v_11, __v_12];
-        if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_237] = [__v_11, __v_12];
+        if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_237: usize = 2;
-const IN_237: usize = 2;
-const OUT_237: usize = 2;
-fn aiur_fn_237(
-  inp: [G; IN_237],
+const INPUT_SIZE_238: usize = 2;
+const IN_238: usize = 2;
+const OUT_238: usize = 2;
+fn aiur_fn_238(
+  inp: [G; IN_238],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_237], 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];
@@ -22591,8 +22610,8 @@ fn aiur_fn_237(
     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_237] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_238] = [__v_0, __v_1];
+        if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -22600,59 +22619,59 @@ fn aiur_fn_237(
         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_237] = { let __args: [G; IN_237] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_237] = [__v_8, __v_9];
-        if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_238] = [__v_8, __v_9];
+        if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_238: usize = 1;
-const IN_238: usize = 1;
-const OUT_238: usize = 4;
-fn aiur_fn_238(
-  inp: [G; IN_238],
+const INPUT_SIZE_239: usize = 1;
+const IN_239: usize = 1;
+const OUT_239: usize = 4;
+fn aiur_fn_239(
+  inp: [G; IN_239],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_238], ExecError> {
+) -> Result<[G; OUT_239], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
-    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     let __v_7: G = G::from_u64(0);
-    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
-    let __ret: [G; OUT_238] = [__v_2, __v_5, __v_8, __v_9];
-    if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_239] = [__v_2, __v_5, __v_8, __v_9];
+    if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_239: usize = 2;
-const IN_239: usize = 2;
-const OUT_239: usize = 1;
-fn aiur_fn_239(
-  inp: [G; IN_239],
+const INPUT_SIZE_240: usize = 2;
+const IN_240: usize = 2;
+const OUT_240: usize = 1;
+fn aiur_fn_240(
+  inp: [G; IN_240],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_239], ExecError> {
+) -> Result<[G; OUT_240], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { 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_239] = { let __args: [G; IN_239] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -22707,8 +22726,8 @@ fn aiur_fn_239(
       1u64 => {
         let __v_37: G = G::from_u64(0);
         let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_239] = [__v_38];
-        if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_240] = [__v_38];
+        if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -22724,8 +22743,8 @@ fn aiur_fn_239(
             let __v_44: G = G::from_u64(0);
             let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_239] = [__v_46];
-            if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_240] = [__v_46];
+            if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -22745,8 +22764,8 @@ fn aiur_fn_239(
                 let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_239] = [__v_52];
-                if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_240] = [__v_52];
+                if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -22766,8 +22785,8 @@ fn aiur_fn_239(
                 let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_239] = [__v_56];
-                if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_240] = [__v_56];
+                if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -22778,212 +22797,212 @@ fn aiur_fn_239(
   })
 }
 
-const INPUT_SIZE_240: usize = 1;
-const IN_240: usize = 1;
-const OUT_240: usize = 1;
-fn aiur_fn_240(
-  inp: [G; IN_240],
+const INPUT_SIZE_241: usize = 1;
+const IN_241: usize = 1;
+const OUT_241: usize = 1;
+fn aiur_fn_241(
+  inp: [G; IN_241],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_240], ExecError> {
+) -> Result<[G; OUT_241], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_240] = [__v_3];
-        if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_241] = [__v_3];
+        if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_240] = [__v_5];
-            if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_241] = [__v_5];
+            if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             match __v_6.as_canonical_u64() {
               1u64 => {
                 let __v_7: G = G::from_u64(1);
-                let __ret: [G; OUT_240] = [__v_7];
-                if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_241] = [__v_7];
+                if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_8: G = __r_arr[0];
                 match __v_8.as_canonical_u64() {
                   1u64 => {
                     let __v_9: G = G::from_u64(1);
-                    let __ret: [G; OUT_240] = [__v_9];
-                    if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_241] = [__v_9];
+                    if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
                     let __v_9: G = __r_arr[0];
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
                     match __v_10.as_canonical_u64() {
                       1u64 => {
                         let __v_11: G = G::from_u64(1);
-                        let __ret: [G; OUT_240] = [__v_11];
-                        if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_241] = [__v_11];
+                        if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
                         let __v_11: G = __r_arr[0];
-                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                         let __v_12: G = __r_arr[0];
                         match __v_12.as_canonical_u64() {
                           1u64 => {
                             let __v_13: G = G::from_u64(1);
-                            let __ret: [G; OUT_240] = [__v_13];
-                            if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_241] = [__v_13];
+                            if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
                             let __v_13: G = __r_arr[0];
-                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                             let __v_14: G = __r_arr[0];
                             match __v_14.as_canonical_u64() {
                               1u64 => {
                                 let __v_15: G = G::from_u64(1);
-                                let __ret: [G; OUT_240] = [__v_15];
-                                if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_241] = [__v_15];
+                                if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
-                                let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
                                 let __v_15: G = __r_arr[0];
-                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                 let __v_16: G = __r_arr[0];
                                 match __v_16.as_canonical_u64() {
                                   1u64 => {
                                     let __v_17: G = G::from_u64(1);
-                                    let __ret: [G; OUT_240] = [__v_17];
-                                    if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_241] = [__v_17];
+                                    if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                   _ => {
-                                    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
                                     let __v_17: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                     let __v_18: G = __r_arr[0];
                                     match __v_18.as_canonical_u64() {
                                       1u64 => {
                                         let __v_19: G = G::from_u64(1);
-                                        let __ret: [G; OUT_240] = [__v_19];
-                                        if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        let __ret: [G; OUT_241] = [__v_19];
+                                        if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
                                         let __v_19: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                         let __v_20: G = __r_arr[0];
                                         match __v_20.as_canonical_u64() {
                                           1u64 => {
                                             let __v_21: G = G::from_u64(1);
-                                            let __ret: [G; OUT_240] = [__v_21];
-                                            if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            let __ret: [G; OUT_241] = [__v_21];
+                                            if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
                                             let __v_21: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                             let __v_22: G = __r_arr[0];
                                             match __v_22.as_canonical_u64() {
                                               1u64 => {
                                                 let __v_23: G = G::from_u64(1);
-                                                let __ret: [G; OUT_240] = [__v_23];
-                                                if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                let __ret: [G; OUT_241] = [__v_23];
+                                                if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                 return Ok(__ret);
                                               },
                                               _ => {
-                                                let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
                                                 let __v_23: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                 let __v_24: G = __r_arr[0];
                                                 match __v_24.as_canonical_u64() {
                                                   1u64 => {
                                                     let __v_25: G = G::from_u64(1);
-                                                    let __ret: [G; OUT_240] = [__v_25];
-                                                    if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                    let __ret: [G; OUT_241] = [__v_25];
+                                                    if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
-                                                    let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
                                                     let __v_25: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                     let __v_26: G = __r_arr[0];
                                                     match __v_26.as_canonical_u64() {
                                                       1u64 => {
                                                         let __v_27: G = G::from_u64(1);
-                                                        let __ret: [G; OUT_240] = [__v_27];
-                                                        if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                        let __ret: [G; OUT_241] = [__v_27];
+                                                        if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                         return Ok(__ret);
                                                       },
                                                       _ => {
-                                                        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
                                                         let __v_27: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                         let __v_28: G = __r_arr[0];
                                                         match __v_28.as_canonical_u64() {
                                                           1u64 => {
                                                             let __v_29: G = G::from_u64(1);
-                                                            let __ret: [G; OUT_240] = [__v_29];
-                                                            if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                            let __ret: [G; OUT_241] = [__v_29];
+                                                            if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                             return Ok(__ret);
                                                           },
                                                           _ => {
-                                                            let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+                                                            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
                                                             let __v_29: G = __r_arr[0];
-                                                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                             let __v_30: G = __r_arr[0];
                                                             match __v_30.as_canonical_u64() {
                                                               1u64 => {
                                                                 let __v_31: G = G::from_u64(1);
-                                                                let __ret: [G; OUT_240] = [__v_31];
-                                                                if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                                let __ret: [G; OUT_241] = [__v_31];
+                                                                if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                                 return Ok(__ret);
                                                               },
                                                               _ => {
-                                                                let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+                                                                let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
                                                                 let __v_31: G = __r_arr[0];
-                                                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                                 let __v_32: G = __r_arr[0];
                                                                 match __v_32.as_canonical_u64() {
                                                                   1u64 => {
                                                                     let __v_33: G = G::from_u64(1);
-                                                                    let __ret: [G; OUT_240] = [__v_33];
-                                                                    if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                                    let __ret: [G; OUT_241] = [__v_33];
+                                                                    if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                                     return Ok(__ret);
                                                                   },
                                                                   _ => {
                                                                     let __v_33: G = G::from_u64(0);
-                                                                    let __ret: [G; OUT_240] = [__v_33];
-                                                                    if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                                    let __ret: [G; OUT_241] = [__v_33];
+                                                                    if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                                     return Ok(__ret);
                                                                   },
                                                                 }
@@ -23020,56 +23039,56 @@ fn aiur_fn_240(
   })
 }
 
-const INPUT_SIZE_241: usize = 1;
-const IN_241: usize = 1;
-const OUT_241: usize = 1;
-fn aiur_fn_241(
-  inp: [G; IN_241],
+const INPUT_SIZE_242: usize = 1;
+const IN_242: usize = 1;
+const OUT_242: usize = 1;
+fn aiur_fn_242(
+  inp: [G; IN_242],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_241], ExecError> {
+) -> Result<[G; OUT_242], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
-    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } };
     let __v_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_20: G = __r_arr[0];
     let __v_21: G = (__v_18 + __v_20);
     let __v_22: G = (__v_16 + __v_21);
@@ -23080,21 +23099,21 @@ fn aiur_fn_241(
     let __v_27: G = (__v_6 + __v_26);
     let __v_28: G = (__v_4 + __v_27);
     let __v_29: G = (__v_2 + __v_28);
-    let __ret: [G; OUT_241] = [__v_29];
-    if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_242] = [__v_29];
+    if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_242: usize = 1;
-const IN_242: usize = 1;
-const OUT_242: usize = 2;
-fn aiur_fn_242(
-  inp: [G; IN_242],
+const INPUT_SIZE_243: usize = 1;
+const IN_243: usize = 1;
+const OUT_243: usize = 2;
+fn aiur_fn_243(
+  inp: [G; IN_243],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_242], ExecError> {
+) -> Result<[G; OUT_243], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -23107,8 +23126,8 @@ fn aiur_fn_242(
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_242] = [__v_5, __v_3];
-            if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_243] = [__v_5, __v_3];
+            if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -23116,16 +23135,16 @@ fn aiur_fn_242(
             let __v_6: G = G::from_u64(1);
             let __v_7: G = G::from_u64(1);
             let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_242] = [__v_5, __v_8];
-            if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_243] = [__v_5, __v_8];
+            if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
@@ -23133,8 +23152,8 @@ fn aiur_fn_242(
             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_242] = [__v_7, __v_10];
-            if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_243] = [__v_7, __v_10];
+            if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -23142,18 +23161,18 @@ fn aiur_fn_242(
             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_242] = [__v_7, __v_10];
-            if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_243] = [__v_7, __v_10];
+            if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_242] = [__v_5, __v_6];
-        if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_243] = [__v_5, __v_6];
+        if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -23161,23 +23180,23 @@ fn aiur_fn_242(
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_242] = [__v_5, __v_8];
-        if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_243] = [__v_5, __v_8];
+        if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_243: usize = 2;
-const IN_243: usize = 2;
-const OUT_243: usize = 2;
-fn aiur_fn_243(
-  inp: [G; IN_243],
+const INPUT_SIZE_244: usize = 2;
+const IN_244: usize = 2;
+const OUT_244: usize = 2;
+fn aiur_fn_244(
+  inp: [G; IN_244],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_243], ExecError> {
+) -> Result<[G; OUT_244], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23188,22 +23207,22 @@ fn aiur_fn_243(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_10: G = G::from_u64(1);
-                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_243] = [__v_10, __v_11];
-                if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_244] = [__v_10, __v_11];
+                if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -23211,8 +23230,8 @@ fn aiur_fn_243(
                 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_243] = [__v_10, __v_13];
-                if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_244] = [__v_10, __v_13];
+                if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -23222,8 +23241,8 @@ fn aiur_fn_243(
             let __v_9: G = G::from_u64(1);
             let __v_10: G = G::from_u64(1);
             let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_243] = [__v_8, __v_11];
-            if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_244] = [__v_8, __v_11];
+            if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -23233,44 +23252,44 @@ fn aiur_fn_243(
         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_243] = [__v_6, __v_9];
-        if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_244] = [__v_6, __v_9];
+        if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_244: usize = 1;
-const IN_244: usize = 1;
-const OUT_244: usize = 1;
-fn aiur_fn_244(
-  inp: [G; IN_244],
+const INPUT_SIZE_245: usize = 1;
+const IN_245: usize = 1;
+const OUT_245: usize = 1;
+fn aiur_fn_245(
+  inp: [G; IN_245],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_244], ExecError> {
+) -> Result<[G; OUT_245], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(7);
     let __v_2: G = G::from_u64(0);
     let __v_3: G = G::from_u64(0);
     let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_244] = [__v_4];
-    if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_245] = [__v_4];
+    if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_245: usize = 1;
-const IN_245: usize = 1;
-const OUT_245: usize = 3;
-fn aiur_fn_245(
-  inp: [G; IN_245],
+const INPUT_SIZE_246: usize = 1;
+const IN_246: usize = 1;
+const OUT_246: usize = 3;
+fn aiur_fn_246(
+  inp: [G; IN_246],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_245], ExecError> {
+) -> Result<[G; OUT_246], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -23287,40 +23306,40 @@ fn aiur_fn_245(
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             match __v_9.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
                 match __v_12.as_canonical_u64() {
                   1u64 => {
                     let __v_13: G = G::from_u64(1);
                     let __v_14: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                     let __v_15: G = __r_arr[0];
-                    let __ret: [G; OUT_245] = [__v_13, __v_14, __v_15];
-                    if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_246] = [__v_13, __v_14, __v_15];
+                    if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
                     let __v_13: G = __r_arr[0];
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_14: G = __r_arr[0];
                     match __v_14.as_canonical_u64() {
                       1u64 => {
                         let __v_15: G = G::from_u64(1);
                         let __v_16: G = G::from_u64(1);
-                        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_17: G = __r_arr[0];
-                        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                         let __v_18: G = __r_arr[0];
-                        let __ret: [G; OUT_245] = [__v_15, __v_16, __v_18];
-                        if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_246] = [__v_15, __v_16, __v_18];
+                        if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       _ => {
@@ -23329,8 +23348,8 @@ fn aiur_fn_245(
                         let __v_17: G = G::from_u64(1);
                         let __v_18: G = G::from_u64(1);
                         let __v_19: G = { let __values: [G; 10] = [__v_17, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_245] = [__v_15, __v_16, __v_19];
-                        if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_246] = [__v_15, __v_16, __v_19];
+                        if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
@@ -23343,8 +23362,8 @@ fn aiur_fn_245(
                 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_245] = [__v_11, __v_12, __v_15];
-                if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_246] = [__v_11, __v_12, __v_15];
+                if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -23355,8 +23374,8 @@ fn aiur_fn_245(
             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_245] = [__v_9, __v_10, __v_13];
-            if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_246] = [__v_9, __v_10, __v_13];
+            if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -23367,41 +23386,41 @@ fn aiur_fn_245(
         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_245] = [__v_5, __v_6, __v_9];
-        if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_246] = [__v_5, __v_6, __v_9];
+        if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_246: usize = 2;
-const IN_246: usize = 2;
-const OUT_246: usize = 1;
-fn aiur_fn_246(
-  inp: [G; IN_246],
+const INPUT_SIZE_247: usize = 2;
+const IN_247: usize = 2;
+const OUT_247: usize = 1;
+fn aiur_fn_247(
+  inp: [G; IN_247],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_246], ExecError> {
+) -> Result<[G; OUT_247], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(1);
-    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_4: G = __r_arr[0];
     let __v_5: G = (__v_3 - __v_4);
     let __v_6: G = (__v_0 * __v_5);
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() {
   0u64 => {
-    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     break '__mc_0 [__v_7];
   },
   _ => {
-    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     break '__mc_0 [__v_7];
   },
@@ -23413,9 +23432,9 @@ fn aiur_fn_246(
     break '__mc_1 [__v_2];
   },
   _ => {
-    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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     break '__mc_1 [__v_9];
   },
@@ -23429,25 +23448,25 @@ fn aiur_fn_246(
     let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_14: G = G::from_u64(0);
     let __v_15: G = { let __values: [G; 4] = [__v_10, __v_7, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
     let __v_17: G = G::from_u64(0);
     let __v_18: G = { let __values: [G; 4] = [__v_9, __v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_246] = [__v_18];
-    if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_247] = [__v_18];
+    if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_247: usize = 4;
-const IN_247: usize = 4;
-const OUT_247: usize = 1;
-fn aiur_fn_247(
-  inp: [G; IN_247],
+const INPUT_SIZE_248: usize = 4;
+const IN_248: usize = 4;
+const OUT_248: usize = 1;
+fn aiur_fn_248(
+  inp: [G; IN_248],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_247], ExecError> {
+) -> Result<[G; OUT_248], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23456,34 +23475,34 @@ fn aiur_fn_247(
     let __v_4: G = (__v_0 - __v_2);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_247] = [__v_6];
-        if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_248] = [__v_6];
+        if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_247] = [__v_7];
-            if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_248] = [__v_7];
+            if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_247] = [__v_7];
-            if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_248] = [__v_7];
+            if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -23492,54 +23511,54 @@ fn aiur_fn_247(
   })
 }
 
-const INPUT_SIZE_248: usize = 3;
-const IN_248: usize = 3;
-const OUT_248: usize = 1;
-fn aiur_fn_248(
-  inp: [G; IN_248],
+const INPUT_SIZE_249: usize = 3;
+const IN_249: usize = 3;
+const OUT_249: usize = 1;
+fn aiur_fn_249(
+  inp: [G; IN_249],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_248], ExecError> {
+) -> Result<[G; OUT_249], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_248] = [__v_4];
-        if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_249] = [__v_4];
+        if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { 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_4: G = __r_arr[0];
         let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
         let __v_7: G = (__v_5 - __v_6);
         let __v_8: G = (__v_0 * __v_7);
         match __v_8.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_248] = [__v_11];
-            if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_249] = [__v_11];
+            if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_248] = [__v_10];
-            if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_249] = [__v_10];
+            if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -23548,21 +23567,21 @@ fn aiur_fn_248(
   })
 }
 
-const INPUT_SIZE_249: usize = 4;
-const IN_249: usize = 4;
-const OUT_249: usize = 1;
-fn aiur_fn_249(
-  inp: [G; IN_249],
+const INPUT_SIZE_250: usize = 4;
+const IN_250: usize = 4;
+const OUT_250: usize = 1;
+fn aiur_fn_250(
+  inp: [G; IN_250],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_249], ExecError> {
+) -> Result<[G; OUT_250], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
@@ -23570,25 +23589,25 @@ fn aiur_fn_249(
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_249] = [__v_9];
-        if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_250] = [__v_9];
+        if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
         let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(1);
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_8: G = __r_arr[0];
         let __v_9: G = (__v_7 - __v_8);
         let __v_10: G = (__v_0 * __v_9);
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
     break '__mc_0 [__v_11];
   },
@@ -23604,54 +23623,54 @@ fn aiur_fn_249(
         let __v_15: G = (__v_2 - __v_14);
         let __v_16: G = (__v_0 + __v_15);
         let __v_17: G = G::from_u64(1);
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
         let __v_19: G = (__v_17 - __v_18);
         let __v_20: G = (__v_16 * __v_19);
-        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_20, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_20, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
-        let __ret: [G; OUT_249] = [__v_21];
-        if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_250] = [__v_21];
+        if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_250: usize = 3;
-const IN_250: usize = 3;
-const OUT_250: usize = 1;
-fn aiur_fn_250(
-  inp: [G; IN_250],
+const INPUT_SIZE_251: usize = 3;
+const IN_251: usize = 3;
+const OUT_251: usize = 1;
+fn aiur_fn_251(
+  inp: [G; IN_251],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_250], ExecError> {
+) -> Result<[G; OUT_251], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_250] = [__v_4];
-        if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_251] = [__v_4];
+        if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { 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_4: G = __r_arr[0];
         let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
         let __v_7: G = (__v_5 - __v_6);
         let __v_8: G = (__v_0 * __v_7);
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     break '__mc_0 [__v_9];
   },
@@ -23674,29 +23693,29 @@ fn aiur_fn_250(
         let __v_20: G = G::from_u64(1);
         let __v_21: G = { let __values: [G; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_22: G = { let __values: [G; 10] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_23, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_23, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { 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_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { 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_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_122] = { let __args: [G; IN_122] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
-            let __ret: [G; OUT_250] = [__v_28];
-            if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_251] = [__v_28];
+            if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_26: G = G::from_u64(0);
-            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
             let __v_27: G = __r_arr[0];
-            let __ret: [G; OUT_250] = [__v_27];
-            if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_251] = [__v_27];
+            if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -23705,20 +23724,20 @@ fn aiur_fn_250(
   })
 }
 
-const INPUT_SIZE_251: usize = 3;
-const IN_251: usize = 3;
-const OUT_251: usize = 1;
-fn aiur_fn_251(
-  inp: [G; IN_251],
+const INPUT_SIZE_252: usize = 3;
+const IN_252: usize = 3;
+const OUT_252: usize = 1;
+fn aiur_fn_252(
+  inp: [G; IN_252],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_251], ExecError> {
+) -> Result<[G; OUT_252], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
@@ -23726,23 +23745,23 @@ fn aiur_fn_251(
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
         let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_251] = [__v_8];
-        if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_252] = [__v_8];
+        if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { 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_4: G = __r_arr[0];
         let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
         let __v_7: G = (__v_5 - __v_6);
         let __v_8: G = (__v_0 * __v_7);
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     break '__mc_0 [__v_9];
   },
@@ -23752,16 +23771,16 @@ fn aiur_fn_251(
 }
  };
         let __v_9: G = __mc_out___mc_0[0];
-        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(1);
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_12: G = __r_arr[0];
         let __v_13: G = (__v_11 - __v_12);
         let __v_14: G = (__v_0 * __v_13);
         let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_14.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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];
     break '__mc_1 [__v_15];
   },
@@ -23772,7 +23791,7 @@ fn aiur_fn_251(
  };
         let __v_15: G = __mc_out___mc_1[0];
         let __v_16: G = G::from_u64(1);
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_17: G = __r_arr[0];
         let __v_18: G = (__v_16 - __v_17);
         let __v_19: G = (__v_0 * __v_18);
@@ -23789,18 +23808,18 @@ fn aiur_fn_251(
         let __v_30: G = G::from_u64(1);
         let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
         let __v_33: G = __r_arr[0];
-        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { 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_34: G = __r_arr[0];
-        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_34, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_34, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { 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_35: G = __r_arr[0];
         match __v_35.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
             let __v_36: G = __r_arr[0];
-            let __ret: [G; OUT_251] = [__v_36];
-            if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_252] = [__v_36];
+            if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -23818,10 +23837,10 @@ fn aiur_fn_251(
             let __v_47: G = G::from_u64(1);
             let __v_48: G = { let __values: [G; 10] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_49: G = { let __values: [G; 10] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_48]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } };
             let __v_50: G = __r_arr[0];
-            let __ret: [G; OUT_251] = [__v_50];
-            if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_252] = [__v_50];
+            if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -23830,15 +23849,15 @@ fn aiur_fn_251(
   })
 }
 
-const INPUT_SIZE_252: usize = 3;
-const IN_252: usize = 3;
-const OUT_252: usize = 2;
-fn aiur_fn_252(
-  inp: [G; IN_252],
+const INPUT_SIZE_253: usize = 3;
+const IN_253: usize = 3;
+const OUT_253: usize = 2;
+fn aiur_fn_253(
+  inp: [G; IN_253],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_252], ExecError> {
+) -> Result<[G; OUT_253], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23847,13 +23866,13 @@ fn aiur_fn_252(
     let __v_3: G = __r_arr[0];
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __v_9: G = (__v_6 + __v_8);
     match __v_9.as_canonical_u64() {
@@ -23867,27 +23886,27 @@ fn aiur_fn_252(
             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_252] = [__v_12, __v_16];
-            if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_253] = [__v_12, __v_16];
+            if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_12: G = G::from_u64(0);
             let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
             let __v_16: G = __r_arr[2];
             match __v_14.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } };
                 let __v_17: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_18: G = __r_arr[0];
                 let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_18.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
     break '__mc_0 [__v_19];
   },
@@ -23895,11 +23914,11 @@ fn aiur_fn_252(
     let __v_19: G = G::from_u64(1);
     let __v_20: G = (__v_19 - __v_15);
     let __v_21: G = G::from_u64(1);
-    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
     let __v_22: G = __r_arr[0];
     let __v_23: G = (__v_21 - __v_22);
     let __v_24: G = (__v_20 * __v_23);
-    let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_24, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_24, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
     let __v_25: G = __r_arr[0];
     break '__mc_0 [__v_25];
   },
@@ -23910,10 +23929,10 @@ fn aiur_fn_252(
                 let __v_21: G = G::from_u64(1);
                 let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
                 let __v_22: G = __r_arr[0];
-                let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_252] = [__v_20, __v_23];
-                if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_253] = [__v_20, __v_23];
+                if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -23922,8 +23941,8 @@ fn aiur_fn_252(
                 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_252] = [__v_17, __v_21];
-                if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_253] = [__v_17, __v_21];
+                if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -23940,25 +23959,25 @@ fn aiur_fn_252(
             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_252] = [__v_12, __v_16];
-            if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_253] = [__v_12, __v_16];
+            if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_12: G = G::from_u64(0);
             let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
             let __v_16: G = __r_arr[2];
             match __v_14.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
                 let __v_17: G = __r_arr[0];
                 let __v_18: G = __r_arr[1];
-                let __ret: [G; OUT_252] = [__v_17, __v_18];
-                if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_253] = [__v_17, __v_18];
+                if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -23967,8 +23986,8 @@ fn aiur_fn_252(
                 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_252] = [__v_17, __v_21];
-                if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_253] = [__v_17, __v_21];
+                if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -23979,31 +23998,31 @@ fn aiur_fn_252(
   })
 }
 
-const INPUT_SIZE_253: usize = 4;
-const IN_253: usize = 4;
-const OUT_253: usize = 2;
-fn aiur_fn_253(
-  inp: [G; IN_253],
+const INPUT_SIZE_254: usize = 4;
+const IN_254: usize = 4;
+const OUT_254: usize = 2;
+fn aiur_fn_254(
+  inp: [G; IN_254],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_253], ExecError> {
+) -> Result<[G; OUT_254], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __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_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = (__v_7 + __v_9);
     let __v_11: G = (__v_5 + __v_10);
@@ -24012,29 +24031,29 @@ fn aiur_fn_253(
         let __v_12: G = G::from_u64(1);
         let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         match __v_14.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_17.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
     break '__mc_0 [__v_18];
   },
   _ => {
-    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
     match __v_19.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         break '__mc_0 [__v_20];
       },
@@ -24053,15 +24072,15 @@ fn aiur_fn_253(
         let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_33: G = G::from_u64(1);
-        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_15, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_15, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { 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_34: G = __r_arr[0];
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_35: G = __r_arr[0];
         let __v_36: G = (__v_33 - __v_35);
         let __v_37: G = (__v_2 * __v_36);
-        let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { 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_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
         let __v_39: G = __r_arr[0];
         break '__mc_0 [__v_39];
       },
@@ -24074,10 +24093,10 @@ fn aiur_fn_253(
             let __v_20: G = G::from_u64(2);
             let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_253] = [__v_19, __v_22];
-            if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_254] = [__v_19, __v_22];
+            if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -24086,8 +24105,8 @@ fn aiur_fn_253(
             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_253] = [__v_16, __v_20];
-            if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_254] = [__v_16, __v_20];
+            if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -24096,44 +24115,44 @@ fn aiur_fn_253(
         let __v_12: G = G::from_u64(1);
         let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         let __v_16: G = __r_arr[2];
         match __v_14.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_18: G = __r_arr[0];
             let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_18.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
     break '__mc_1 [__v_19];
   },
   _ => {
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_20: G = __r_arr[0];
     match __v_20.as_canonical_u64() {
       1u64 => {
         let __v_21: G = G::from_u64(1);
         let __v_22: G = (__v_21 - __v_15);
         let __v_23: G = G::from_u64(1);
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_24: G = __r_arr[0];
         let __v_25: G = (__v_23 - __v_24);
         let __v_26: G = (__v_22 * __v_25);
-        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
         break '__mc_1 [__v_27];
       },
       _ => {
-        let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
         match __v_22.as_canonical_u64() {
           1u64 => {
@@ -24143,34 +24162,34 @@ fn aiur_fn_253(
             let __v_26: G = (__v_15 - __v_25);
             let __v_27: G = (__v_2 + __v_26);
             let __v_28: G = G::from_u64(1);
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_29: G = __r_arr[0];
             let __v_30: G = (__v_28 - __v_29);
             let __v_31: G = G::from_u64(1);
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_32: G = __r_arr[0];
             let __v_33: G = (__v_31 - __v_32);
             let __v_34: G = (__v_30 * __v_33);
             let __v_35: G = (__v_27 * __v_34);
-            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
             let __v_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
             let __v_37: G = __r_arr[0];
             break '__mc_1 [__v_37];
           },
           _ => {
-            let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_24: G = __r_arr[0];
             match __v_24.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } };
                 let __v_25: G = __r_arr[0];
                 break '__mc_1 [__v_25];
               },
               _ => {
-                let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } };
                 let __v_25: G = __r_arr[0];
                 break '__mc_1 [__v_25];
               },
@@ -24187,10 +24206,10 @@ fn aiur_fn_253(
             let __v_21: G = G::from_u64(2);
             let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_253] = [__v_20, __v_23];
-            if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_254] = [__v_20, __v_23];
+            if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -24199,8 +24218,8 @@ fn aiur_fn_253(
             let __v_19: G = G::from_u64(0);
             let __v_20: G = G::from_u64(0);
             let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_253] = [__v_17, __v_21];
-            if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_254] = [__v_17, __v_21];
+            if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -24209,15 +24228,15 @@ fn aiur_fn_253(
   })
 }
 
-const INPUT_SIZE_254: usize = 2;
-const IN_254: usize = 2;
-const OUT_254: usize = 1;
-fn aiur_fn_254(
-  inp: [G; IN_254],
+const INPUT_SIZE_255: usize = 2;
+const IN_255: usize = 2;
+const OUT_255: usize = 1;
+fn aiur_fn_255(
+  inp: [G; IN_255],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_254], ExecError> {
+) -> Result<[G; OUT_255], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24227,18 +24246,18 @@ fn aiur_fn_254(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_254] = [__v_0];
-        if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_255] = [__v_0];
+        if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(3);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_254] = [__v_8];
-        if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_255] = [__v_8];
+        if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -24248,264 +24267,264 @@ fn aiur_fn_254(
   })
 }
 
-const INPUT_SIZE_255: usize = 3;
-const IN_255: usize = 3;
-const OUT_255: usize = 2;
-fn aiur_fn_255(
-  inp: [G; IN_255],
+const INPUT_SIZE_256: usize = 3;
+const IN_256: usize = 3;
+const OUT_256: usize = 2;
+fn aiur_fn_256(
+  inp: [G; IN_256],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_255], ExecError> {
+) -> Result<[G; OUT_256], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_255] = [__v_5, __v_8];
-        if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_256] = [__v_5, __v_8];
+        if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_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_122] = { let __args: [G; IN_122] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_255] = [__v_7, __v_10];
-            if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_256] = [__v_7, __v_10];
+            if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_9: G = G::from_u64(1);
-                let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
-                let __ret: [G; OUT_255] = [__v_9, __v_12];
-                if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_256] = [__v_9, __v_12];
+                if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
                 match __v_10.as_canonical_u64() {
                   1u64 => {
                     let __v_11: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
-                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                     let __v_13: G = __r_arr[0];
-                    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                     let __v_14: G = __r_arr[0];
-                    let __ret: [G; OUT_255] = [__v_11, __v_14];
-                    if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_256] = [__v_11, __v_14];
+                    if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
                     let __v_11: G = __r_arr[0];
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
                     match __v_12.as_canonical_u64() {
                       1u64 => {
                         let __v_13: G = G::from_u64(1);
-                        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { 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_14: G = __r_arr[0];
-                        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                         let __v_15: G = __r_arr[0];
-                        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                         let __v_16: G = __r_arr[0];
-                        let __ret: [G; OUT_255] = [__v_13, __v_16];
-                        if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_256] = [__v_13, __v_16];
+                        if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
                         let __v_13: G = __r_arr[0];
-                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                         let __v_14: G = __r_arr[0];
                         match __v_14.as_canonical_u64() {
                           1u64 => {
                             let __v_15: G = G::from_u64(1);
-                            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { 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_16: G = __r_arr[0];
-                            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                             let __v_17: G = __r_arr[0];
-                            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                             let __v_18: G = __r_arr[0];
-                            let __ret: [G; OUT_255] = [__v_15, __v_18];
-                            if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_256] = [__v_15, __v_18];
+                            if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
                             let __v_15: G = __r_arr[0];
-                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                             let __v_16: G = __r_arr[0];
                             match __v_16.as_canonical_u64() {
                               1u64 => {
                                 let __v_17: G = G::from_u64(1);
-                                let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { 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_18: G = __r_arr[0];
-                                let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                                 let __v_19: G = __r_arr[0];
-                                let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                                 let __v_20: G = __r_arr[0];
-                                let __ret: [G; OUT_255] = [__v_17, __v_20];
-                                if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_256] = [__v_17, __v_20];
+                                if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
-                                let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
                                 let __v_17: G = __r_arr[0];
-                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                 let __v_18: G = __r_arr[0];
                                 match __v_18.as_canonical_u64() {
                                   1u64 => {
                                     let __v_19: G = G::from_u64(1);
-                                    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { 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_20: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                                     let __v_21: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                                     let __v_22: G = __r_arr[0];
-                                    let __ret: [G; OUT_255] = [__v_19, __v_22];
-                                    if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_256] = [__v_19, __v_22];
+                                    if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                   _ => {
-                                    let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
                                     let __v_19: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                     let __v_20: G = __r_arr[0];
                                     match __v_20.as_canonical_u64() {
                                       1u64 => {
                                         let __v_21: G = G::from_u64(1);
-                                        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
                                         let __v_22: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                                         let __v_23: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                                         let __v_24: G = __r_arr[0];
-                                        let __ret: [G; OUT_255] = [__v_21, __v_24];
-                                        if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        let __ret: [G; OUT_256] = [__v_21, __v_24];
+                                        if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
                                         let __v_21: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                         let __v_22: G = __r_arr[0];
                                         match __v_22.as_canonical_u64() {
                                           1u64 => {
                                             let __v_23: G = G::from_u64(1);
-                                            let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
                                             let __v_24: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                                            let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                                             let __v_25: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                                             let __v_26: G = __r_arr[0];
-                                            let __ret: [G; OUT_255] = [__v_23, __v_26];
-                                            if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            let __ret: [G; OUT_256] = [__v_23, __v_26];
+                                            if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
                                             let __v_23: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                             let __v_24: G = __r_arr[0];
                                             match __v_24.as_canonical_u64() {
                                               1u64 => {
                                                 let __v_25: G = G::from_u64(1);
-                                                let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
                                                 let __v_26: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                                                 let __v_27: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                                                 let __v_28: G = __r_arr[0];
-                                                let __ret: [G; OUT_255] = [__v_25, __v_28];
-                                                if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                let __ret: [G; OUT_256] = [__v_25, __v_28];
+                                                if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                 return Ok(__ret);
                                               },
                                               _ => {
-                                                let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
                                                 let __v_25: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                 let __v_26: G = __r_arr[0];
                                                 match __v_26.as_canonical_u64() {
                                                   1u64 => {
                                                     let __v_27: G = G::from_u64(1);
-                                                    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
                                                     let __v_28: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                                                     let __v_29: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                                                     let __v_30: G = __r_arr[0];
-                                                    let __ret: [G; OUT_255] = [__v_27, __v_30];
-                                                    if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                    let __ret: [G; OUT_256] = [__v_27, __v_30];
+                                                    if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
-                                                    let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
                                                     let __v_27: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                     let __v_28: G = __r_arr[0];
                                                     match __v_28.as_canonical_u64() {
                                                       1u64 => {
                                                         let __v_29: G = G::from_u64(1);
-                                                        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
                                                         let __v_30: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
                                                         let __v_31: G = __r_arr[0];
-                                                        let __ret: [G; OUT_255] = [__v_29, __v_31];
-                                                        if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                        let __ret: [G; OUT_256] = [__v_29, __v_31];
+                                                        if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                         return Ok(__ret);
                                                       },
                                                       _ => {
-                                                        let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
                                                         let __v_29: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                         let __v_30: G = __r_arr[0];
                                                         match __v_30.as_canonical_u64() {
                                                           1u64 => {
                                                             let __v_31: G = G::from_u64(1);
-                                                            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+                                                            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { 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_32: G = __r_arr[0];
-                                                            let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
+                                                            let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
                                                             let __v_33: G = __r_arr[0];
-                                                            let __ret: [G; OUT_255] = [__v_31, __v_33];
-                                                            if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                            let __ret: [G; OUT_256] = [__v_31, __v_33];
+                                                            if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                             return Ok(__ret);
                                                           },
                                                           _ => {
@@ -24514,8 +24533,8 @@ fn aiur_fn_255(
                                                             let __v_33: G = G::from_u64(0);
                                                             let __v_34: G = G::from_u64(0);
                                                             let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                            let __ret: [G; OUT_255] = [__v_31, __v_35];
-                                                            if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                            let __ret: [G; OUT_256] = [__v_31, __v_35];
+                                                            if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                                             return Ok(__ret);
                                                           },
                                                         }
@@ -24548,15 +24567,15 @@ fn aiur_fn_255(
   })
 }
 
-const INPUT_SIZE_256: usize = 2;
-const IN_256: usize = 2;
-const OUT_256: usize = 3;
-fn aiur_fn_256(
-  inp: [G; IN_256],
+const INPUT_SIZE_257: usize = 2;
+const IN_257: usize = 2;
+const OUT_257: usize = 3;
+fn aiur_fn_257(
+  inp: [G; IN_257],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_256], ExecError> {
+) -> Result<[G; OUT_257], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24567,9 +24586,9 @@ fn aiur_fn_256(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           0u64 => {
@@ -24577,8 +24596,8 @@ fn aiur_fn_256(
             let __v_9: G = G::from_u64(1);
             let __v_10: G = G::from_u64(1);
             let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_256] = [__v_8, __v_0, __v_11];
-            if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_257] = [__v_8, __v_0, __v_11];
+            if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -24604,8 +24623,8 @@ fn aiur_fn_256(
                     match __v_16.as_canonical_u64() {
                       0u64 => {
                         let __v_19: G = G::from_u64(1);
-                        let __ret: [G; OUT_256] = [__v_19, __v_12, __v_17];
-                        if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_257] = [__v_19, __v_12, __v_17];
+                        if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       _ => {
@@ -24613,8 +24632,8 @@ fn aiur_fn_256(
                         let __v_20: G = G::from_u64(1);
                         let __v_21: G = G::from_u64(1);
                         let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_256] = [__v_19, __v_0, __v_22];
-                        if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_257] = [__v_19, __v_0, __v_22];
+                        if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
@@ -24624,8 +24643,8 @@ fn aiur_fn_256(
                     let __v_20: G = G::from_u64(1);
                     let __v_21: G = G::from_u64(1);
                     let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_256] = [__v_19, __v_0, __v_22];
-                    if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_257] = [__v_19, __v_0, __v_22];
+                    if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
@@ -24635,8 +24654,8 @@ fn aiur_fn_256(
                 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_256] = [__v_11, __v_0, __v_14];
-                if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_257] = [__v_11, __v_0, __v_14];
+                if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -24648,23 +24667,23 @@ fn aiur_fn_256(
         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_256] = [__v_6, __v_0, __v_9];
-        if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_257] = [__v_6, __v_0, __v_9];
+        if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_257: usize = 2;
-const IN_257: usize = 2;
-const OUT_257: usize = 1;
-fn aiur_fn_257(
-  inp: [G; IN_257],
+const INPUT_SIZE_258: usize = 2;
+const IN_258: usize = 2;
+const OUT_258: usize = 1;
+fn aiur_fn_258(
+  inp: [G; IN_258],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_257], ExecError> {
+) -> Result<[G; OUT_258], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24681,32 +24700,32 @@ fn aiur_fn_257(
     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_122] = { let __args: [G; IN_122] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
     let __v_17: G = G::from_u64(2);
-    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
     let __v_19: G = G::from_u64(1);
     let __v_20: G = G::from_u64(1);
     let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_22: G = G::from_u64(0);
     let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_24: G = __r_arr[0];
     match __v_24.as_canonical_u64() {
       1u64 => {
         let __v_25: G = G::from_u64(3);
         let __v_26: G = G::from_u64(0);
         let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_257] = [__v_27];
-        if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_258] = [__v_27];
+        if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_25: G = G::from_u64(2);
-        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
         let __v_27: G = G::from_u64(1);
         let __v_28: G = G::from_u64(1);
@@ -24726,23 +24745,23 @@ fn aiur_fn_257(
         let __v_42: G = G::from_u64(3);
         let __v_43: G = G::from_u64(0);
         let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_257] = [__v_44];
-        if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_258] = [__v_44];
+        if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_258: usize = 1;
-const IN_258: usize = 1;
-const OUT_258: usize = 1;
-fn aiur_fn_258(
-  inp: [G; IN_258],
+const INPUT_SIZE_259: usize = 1;
+const IN_259: usize = 1;
+const OUT_259: usize = 1;
+fn aiur_fn_259(
+  inp: [G; IN_259],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_258], ExecError> {
+) -> Result<[G; OUT_259], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -24752,12 +24771,12 @@ fn aiur_fn_258(
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       7u64 => {
-        let __ret: [G; OUT_258] = [__v_0];
-        if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_259] = [__v_0];
+        if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_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 };
@@ -24767,41 +24786,41 @@ fn aiur_fn_258(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
             let __v_13: G = __r_arr[2];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
-                let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_15: G = __r_arr[0];
                 match __v_15.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_258] = [__v_0];
-                    if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_259] = [__v_0];
+                    if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
                     let __v_16: G = __r_arr[0];
-                    let __ret: [G; OUT_258] = [__v_16];
-                    if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_259] = [__v_16];
+                    if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_258] = [__v_0];
-                if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_259] = [__v_0];
+                if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_258] = [__v_0];
-            if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_259] = [__v_0];
+            if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -24810,33 +24829,33 @@ fn aiur_fn_258(
   })
 }
 
-const INPUT_SIZE_259: usize = 3;
-const IN_259: usize = 3;
-const OUT_259: usize = 2;
-fn aiur_fn_259(
-  inp: [G; IN_259],
+const INPUT_SIZE_260: usize = 3;
+const IN_260: usize = 3;
+const OUT_260: usize = 2;
+fn aiur_fn_260(
+  inp: [G; IN_260],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_259], ExecError> {
+) -> Result<[G; OUT_260], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_259] = [__v_4, __v_5];
-        if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_260] = [__v_4, __v_5];
+        if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(2);
-        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
@@ -24847,30 +24866,30 @@ fn aiur_fn_259(
         let __v_12: G = G::from_u64(3);
         let __v_13: G = G::from_u64(0);
         let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
         let __v_15: G = __r_arr[0];
         let __v_16: G = G::from_u64(0);
         let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_18: G = G::from_u64(1);
-        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_259] = [__v_18, __v_19];
-        if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_260] = [__v_18, __v_19];
+        if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_260: usize = 1;
-const IN_260: usize = 1;
-const OUT_260: usize = 1;
-fn aiur_fn_260(
-  inp: [G; IN_260],
+const INPUT_SIZE_261: usize = 1;
+const IN_261: usize = 1;
+const OUT_261: usize = 1;
+fn aiur_fn_261(
+  inp: [G; IN_261],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_260], ExecError> {
+) -> Result<[G; OUT_261], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -24887,7 +24906,7 @@ fn aiur_fn_260(
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_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 };
@@ -24897,15 +24916,15 @@ fn aiur_fn_260(
             let __v_14: G = __loaded[3];
             match __v_11.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
                 let __v_15: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_16: G = __r_arr[0];
                 match __v_16.as_canonical_u64() {
                   0u64 => {
                     let __v_17: G = G::from_u64(0);
-                    let __ret: [G; OUT_260] = [__v_17];
-                    if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_261] = [__v_17];
+                    if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -24926,22 +24945,22 @@ fn aiur_fn_260(
                         match __v_22.as_canonical_u64() {
                           0u64 => {
                             let __v_26: G = G::from_bool((__v_23 == G::ZERO));
-                            let __ret: [G; OUT_260] = [__v_26];
-                            if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_261] = [__v_26];
+                            if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_26: G = G::from_u64(0);
-                            let __ret: [G; OUT_260] = [__v_26];
-                            if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_261] = [__v_26];
+                            if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_20: G = G::from_u64(0);
-                        let __ret: [G; OUT_260] = [__v_20];
-                        if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_261] = [__v_20];
+                        if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
@@ -24950,39 +24969,39 @@ fn aiur_fn_260(
               },
               _ => {
                 let __v_15: G = G::from_u64(0);
-                let __ret: [G; OUT_260] = [__v_15];
-                if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_261] = [__v_15];
+                if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_260] = [__v_9];
-            if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_261] = [__v_9];
+            if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_260] = [__v_5];
-        if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_261] = [__v_5];
+        if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_261: usize = 5;
-const IN_261: usize = 5;
-const OUT_261: usize = 2;
-fn aiur_fn_261(
-  inp: [G; IN_261],
+const INPUT_SIZE_262: usize = 5;
+const IN_262: usize = 5;
+const OUT_262: usize = 2;
+fn aiur_fn_262(
+  inp: [G; IN_262],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_261], ExecError> {
+) -> Result<[G; OUT_262], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24998,14 +25017,14 @@ fn aiur_fn_261(
         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_261] = [__v_7, __v_11];
-        if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_262] = [__v_7, __v_11];
+        if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
@@ -25015,8 +25034,8 @@ fn aiur_fn_261(
             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_261] = [__v_10, __v_14];
-            if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_262] = [__v_10, __v_14];
+            if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
@@ -25025,7 +25044,7 @@ fn aiur_fn_261(
             let __v_12: G = (__v_10 + __v_11);
             let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
             match __v_14.as_canonical_u64() {
               0u64 => {
@@ -25034,8 +25053,8 @@ fn aiur_fn_261(
                 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_261] = [__v_15, __v_19];
-                if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_262] = [__v_15, __v_19];
+                if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -25045,28 +25064,28 @@ fn aiur_fn_261(
                 let __v_17: G = (__v_4 + __v_16);
                 let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
                 let __v_18: G = __r_arr[0];
-                let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
                 let __v_19: G = __r_arr[0];
                 let __v_20: G = __r_arr[1];
                 match __v_19.as_canonical_u64() {
                   1u64 => {
                     let __v_21: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_20, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_20, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
                     let __v_22: G = __r_arr[0];
-                    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                     let __v_23: G = __r_arr[0];
-                    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_23, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_23, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                     let __v_24: G = __r_arr[0];
-                    let __ret: [G; OUT_261] = [__v_21, __v_24];
-                    if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_262] = [__v_21, __v_24];
+                    if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } };
                     let __v_21: G = __r_arr[0];
                     let __v_22: G = __r_arr[1];
-                    let __ret: [G; OUT_261] = [__v_21, __v_22];
-                    if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_262] = [__v_21, __v_22];
+                    if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
@@ -25082,28 +25101,28 @@ fn aiur_fn_261(
   })
 }
 
-const INPUT_SIZE_262: usize = 3;
-const IN_262: usize = 3;
-const OUT_262: usize = 2;
-fn aiur_fn_262(
-  inp: [G; IN_262],
+const INPUT_SIZE_263: usize = 3;
+const IN_263: usize = 3;
+const OUT_263: usize = 2;
+fn aiur_fn_263(
+  inp: [G; IN_263],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_262], ExecError> {
+) -> Result<[G; OUT_263], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     match __v_7.as_canonical_u64() {
       1u64 => {
@@ -25116,15 +25135,15 @@ fn aiur_fn_262(
             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_262] = [__v_10, __v_14];
-            if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_263] = [__v_10, __v_14];
+            if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(0);
             let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             match __v_12.as_canonical_u64() {
@@ -25133,14 +25152,14 @@ fn aiur_fn_262(
                 let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
                 let __v_15: G = __r_arr[0];
                 let __v_16: G = G::from_u64(1);
-                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_17: G = __r_arr[0];
-                let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                 let __v_18: G = __r_arr[0];
-                let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_18, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                 let __v_19: G = __r_arr[0];
-                let __ret: [G; OUT_262] = [__v_16, __v_19];
-                if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_263] = [__v_16, __v_19];
+                if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -25149,8 +25168,8 @@ fn aiur_fn_262(
                 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_262] = [__v_14, __v_18];
-                if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_263] = [__v_14, __v_18];
+                if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -25169,15 +25188,15 @@ fn aiur_fn_262(
                 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_262] = [__v_10, __v_14];
-                if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_263] = [__v_10, __v_14];
+                if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_10: G = G::from_u64(0);
                 let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
                 let __v_13: G = __r_arr[1];
                 match __v_12.as_canonical_u64() {
@@ -25186,16 +25205,16 @@ fn aiur_fn_262(
                     let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
                     let __v_15: G = __r_arr[0];
                     let __v_16: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
                     let __v_17: G = __r_arr[0];
-                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                     let __v_18: G = __r_arr[0];
-                    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                     let __v_19: G = __r_arr[0];
-                    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                     let __v_20: G = __r_arr[0];
-                    let __ret: [G; OUT_262] = [__v_16, __v_20];
-                    if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_263] = [__v_16, __v_20];
+                    if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -25204,8 +25223,8 @@ fn aiur_fn_262(
                     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_262] = [__v_14, __v_18];
-                    if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_263] = [__v_14, __v_18];
+                    if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
@@ -25213,11 +25232,11 @@ fn aiur_fn_262(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
-            let __ret: [G; OUT_262] = [__v_8, __v_9];
-            if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_263] = [__v_8, __v_9];
+            if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -25226,15 +25245,15 @@ fn aiur_fn_262(
   })
 }
 
-const INPUT_SIZE_263: usize = 3;
-const IN_263: usize = 3;
-const OUT_263: usize = 2;
-fn aiur_fn_263(
-  inp: [G; IN_263],
+const INPUT_SIZE_264: usize = 3;
+const IN_264: usize = 3;
+const OUT_264: usize = 2;
+fn aiur_fn_264(
+  inp: [G; IN_264],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_263], ExecError> {
+) -> Result<[G; OUT_264], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -25248,8 +25267,8 @@ fn aiur_fn_263(
         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_263] = [__v_5, __v_9];
-        if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_264] = [__v_5, __v_9];
+        if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -25259,17 +25278,17 @@ fn aiur_fn_263(
         let __v_7: G = G::from_u64(1);
         let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 match __v_13.as_canonical_u64() {
@@ -25278,10 +25297,10 @@ fn aiur_fn_263(
                     let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
                     let __v_16: G = __r_arr[0];
                     let __v_17: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                     let __v_18: G = __r_arr[0];
-                    let __ret: [G; OUT_263] = [__v_17, __v_18];
-                    if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_264] = [__v_17, __v_18];
+                    if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -25290,8 +25309,8 @@ fn aiur_fn_263(
                     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_263] = [__v_15, __v_19];
-                    if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_264] = [__v_15, __v_19];
+                    if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
@@ -25302,23 +25321,23 @@ fn aiur_fn_263(
                 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_263] = [__v_13, __v_17];
-                if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_264] = [__v_13, __v_17];
+                if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
-                let __ret: [G; OUT_263] = [__v_13, __v_14];
-                if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_264] = [__v_13, __v_14];
+                if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -25327,8 +25346,8 @@ fn aiur_fn_263(
                 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_263] = [__v_13, __v_17];
-                if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_264] = [__v_13, __v_17];
+                if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -25339,43 +25358,43 @@ fn aiur_fn_263(
   })
 }
 
-const INPUT_SIZE_264: usize = 4;
-const IN_264: usize = 4;
-const OUT_264: usize = 2;
-fn aiur_fn_264(
-  inp: [G; IN_264],
+const INPUT_SIZE_265: usize = 4;
+const IN_265: usize = 4;
+const OUT_265: usize = 2;
+fn aiur_fn_265(
+  inp: [G; IN_265],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_264], ExecError> {
+) -> Result<[G; OUT_265], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = (__v_7 + __v_9);
     let __v_11: G = G::from_u64(1);
-    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_12: G = __r_arr[0];
     let __v_13: G = (__v_11 - __v_12);
     let __v_14: G = G::from_u64(1);
-    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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
-    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_17: G = __r_arr[0];
     let __v_18: G = (__v_14 - __v_17);
     let __v_19: G = (__v_13 * __v_18);
@@ -25388,8 +25407,8 @@ fn aiur_fn_264(
         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_264] = [__v_22, __v_26];
-        if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_265] = [__v_22, __v_26];
+        if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -25398,14 +25417,14 @@ fn aiur_fn_264(
         let __v_23: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_24: G = __r_arr[0];
             let __v_25: G = __r_arr[1];
             match __v_24.as_canonical_u64() {
               1u64 => {
                 let __v_26: G = G::from_u64(2);
-                let __ret: [G; OUT_264] = [__v_26, __v_25];
-                if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_265] = [__v_26, __v_25];
+                if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -25414,18 +25433,18 @@ fn aiur_fn_264(
                 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_264] = [__v_26, __v_30];
-                if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_265] = [__v_26, __v_30];
+                if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_24: G = G::from_u64(2);
-            let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
             let __v_25: G = __r_arr[0];
-            let __ret: [G; OUT_264] = [__v_24, __v_25];
-            if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_265] = [__v_24, __v_25];
+            if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -25434,15 +25453,15 @@ fn aiur_fn_264(
   })
 }
 
-const INPUT_SIZE_265: usize = 4;
-const IN_265: usize = 4;
-const OUT_265: usize = 1;
-fn aiur_fn_265(
-  inp: [G; IN_265],
+const INPUT_SIZE_266: usize = 4;
+const IN_266: usize = 4;
+const OUT_266: usize = 1;
+fn aiur_fn_266(
+  inp: [G; IN_266],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_265], ExecError> {
+) -> Result<[G; OUT_266], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -25458,27 +25477,27 @@ fn aiur_fn_265(
     let __v_11: G = G::from_u64(3);
     let __v_12: G = G::from_u64(0);
     let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
     let __v_15: G = G::from_u64(0);
     let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
     let __v_17: G = __r_arr[0];
-    let __ret: [G; OUT_265] = [__v_17];
-    if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_266] = [__v_17];
+    if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_266: usize = 10;
-const IN_266: usize = 10;
-const OUT_266: usize = 8;
-fn aiur_fn_266(
-  inp: [G; IN_266],
+const INPUT_SIZE_267: usize = 10;
+const IN_267: usize = 10;
+const OUT_267: usize = 8;
+fn aiur_fn_267(
+  inp: [G; IN_267],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_266], ExecError> {
+) -> Result<[G; OUT_267], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -25492,8 +25511,8 @@ fn aiur_fn_266(
     let __v_9: G = inp[9];
     match __v_9.as_canonical_u64() {
       8u64 => {
-        let __ret: [G; OUT_266] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_267] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -25503,15 +25522,15 @@ fn aiur_fn_266(
         let __v_12: G = __loaded[2];
         match __v_10.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_266] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-            if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_267] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+            if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_13: G = G::from_u64(1);
-                let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25520,13 +25539,13 @@ fn aiur_fn_266(
                 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_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_13: G = G::from_u64(2);
-                let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25535,13 +25554,13 @@ fn aiur_fn_266(
                 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_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               2u64 => {
                 let __v_13: G = G::from_u64(3);
-                let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25550,13 +25569,13 @@ fn aiur_fn_266(
                 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_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               3u64 => {
                 let __v_13: G = G::from_u64(4);
-                let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25565,13 +25584,13 @@ fn aiur_fn_266(
                 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_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               4u64 => {
                 let __v_13: G = G::from_u64(5);
-                let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25580,13 +25599,13 @@ fn aiur_fn_266(
                 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_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               5u64 => {
                 let __v_13: G = G::from_u64(6);
-                let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25595,13 +25614,13 @@ fn aiur_fn_266(
                 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_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               6u64 => {
                 let __v_13: G = G::from_u64(7);
-                let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25610,13 +25629,13 @@ fn aiur_fn_266(
                 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_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_13: G = G::from_u64(8);
-                let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__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[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25625,8 +25644,8 @@ fn aiur_fn_266(
                 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_266] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -25640,22 +25659,22 @@ fn aiur_fn_266(
   })
 }
 
-const INPUT_SIZE_267: usize = 2;
-const IN_267: usize = 2;
-const OUT_267: usize = 1;
-fn aiur_fn_267(
-  inp: [G; IN_267],
+const INPUT_SIZE_268: usize = 2;
+const IN_268: usize = 2;
+const OUT_268: usize = 1;
+fn aiur_fn_268(
+  inp: [G; IN_268],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_267], ExecError> {
+) -> Result<[G; OUT_268], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_267] = [__v_0];
-        if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_268] = [__v_0];
+        if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -25668,17 +25687,17 @@ fn aiur_fn_267(
             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_267] = [__v_7];
-            if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_268] = [__v_7];
+            if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
             let __v_5: G = G::from_u64(1);
             let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_267] = [__v_7];
-            if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_268] = [__v_7];
+            if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -25690,15 +25709,15 @@ fn aiur_fn_267(
   })
 }
 
-const INPUT_SIZE_268: usize = 1;
-const IN_268: usize = 1;
-const OUT_268: usize = 1;
-fn aiur_fn_268(
-  inp: [G; IN_268],
+const INPUT_SIZE_269: usize = 1;
+const IN_269: usize = 1;
+const OUT_269: usize = 1;
+fn aiur_fn_269(
+  inp: [G; IN_269],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_268], ExecError> {
+) -> Result<[G; OUT_269], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -25710,7 +25729,7 @@ fn aiur_fn_268(
     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_266] = { let __args: [G; IN_266] = [__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[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -25720,7 +25739,7 @@ fn aiur_fn_268(
     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_267] = { let __args: [G; IN_267] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_20: G = __loaded[0];
@@ -25734,7 +25753,7 @@ fn aiur_fn_268(
     break '__mc_0 [__v_25];
   },
   _ => {
-    let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
     let __v_23: G = __r_arr[0];
     break '__mc_0 [__v_23];
   },
@@ -25754,15 +25773,15 @@ fn aiur_fn_268(
     let __v_33: G = __loaded[9];
     match __v_24.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_34: G = __r_arr[0];
         match __v_34.as_canonical_u64() {
           1u64 => {
             let __v_35: G = G::from_u64(1);
             let __v_36: G = G::from_u64(1);
             let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_268] = [__v_37];
-            if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_269] = [__v_37];
+            if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
@@ -25771,8 +25790,8 @@ fn aiur_fn_268(
             let __v_37: G = G::from_u64(1);
             let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_268] = [__v_39];
-            if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_269] = [__v_39];
+            if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -25783,23 +25802,23 @@ fn aiur_fn_268(
       _ => {
         let __v_34: G = G::from_u64(0);
         let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_268] = [__v_35];
-        if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_269] = [__v_35];
+        if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_269: usize = 1;
-const IN_269: usize = 1;
-const OUT_269: usize = 1;
-fn aiur_fn_269(
-  inp: [G; IN_269],
+const INPUT_SIZE_270: usize = 1;
+const IN_270: usize = 1;
+const OUT_270: usize = 1;
+fn aiur_fn_270(
+  inp: [G; IN_270],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_269], ExecError> {
+) -> Result<[G; OUT_270], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
@@ -25817,50 +25836,50 @@ fn aiur_fn_269(
         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_269] = [__v_12];
-        if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_270] = [__v_12];
+        if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
         let __v_10: G = G::from_u64(1);
-        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_269] = [__v_13];
-        if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_270] = [__v_13];
+        if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
         let __v_10: G = G::from_u64(2);
-        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_269] = [__v_13];
-        if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_270] = [__v_13];
+        if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
         let __v_10: G = G::from_u64(3);
-        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_269] = [__v_13];
-        if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_270] = [__v_13];
+        if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
         let __v_10: G = G::from_u64(4);
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_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_269] = [__v_13];
-        if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_270] = [__v_13];
+        if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -25870,15 +25889,15 @@ fn aiur_fn_269(
   })
 }
 
-const INPUT_SIZE_270: usize = 2;
-const IN_270: usize = 2;
-const OUT_270: usize = 1;
-fn aiur_fn_270(
-  inp: [G; IN_270],
+const INPUT_SIZE_271: usize = 2;
+const IN_271: usize = 2;
+const OUT_271: usize = 1;
+fn aiur_fn_271(
+  inp: [G; IN_271],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_270], ExecError> {
+) -> Result<[G; OUT_271], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -25898,23 +25917,23 @@ fn aiur_fn_270(
         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_270] = [__v_14];
-        if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_271] = [__v_14];
+        if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_12: G = __r_arr[0];
         let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
         let __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_270] = [__v_17];
-        if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_271] = [__v_17];
+        if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -25924,15 +25943,15 @@ fn aiur_fn_270(
   })
 }
 
-const INPUT_SIZE_271: usize = 5;
-const IN_271: usize = 5;
-const OUT_271: usize = 1;
-fn aiur_fn_271(
-  inp: [G; IN_271],
+const INPUT_SIZE_272: usize = 5;
+const IN_272: usize = 5;
+const OUT_272: usize = 1;
+fn aiur_fn_272(
+  inp: [G; IN_272],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_271], ExecError> {
+) -> Result<[G; OUT_272], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -25960,156 +25979,156 @@ fn aiur_fn_271(
     let __v_22: G = __loaded[17];
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
         let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
         let __v_25: G = G::from_u64(1);
-        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
         let __v_27: G = G::from_u64(0);
         let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_271] = [__v_28];
-        if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_272] = [__v_28];
+        if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
         let __v_23: G = G::from_u64(0);
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_24: G = __r_arr[0];
         let __v_25: G = G::from_u64(0);
         let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_271] = [__v_26];
-        if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_272] = [__v_26];
+        if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
         let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(2);
         let __v_27: G = G::from_u64(0);
         let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_271] = [__v_28];
-        if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_272] = [__v_28];
+        if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
         let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(2);
         let __v_27: G = G::from_u64(0);
         let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_271] = [__v_28];
-        if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_272] = [__v_28];
+        if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
         let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
         let __v_25: G = G::from_u64(8);
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
         let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_271] = [__v_28];
-        if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_272] = [__v_28];
+        if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
         let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } };
         let __v_26: G = G::from_u64(7);
         let __v_27: G = G::from_u64(1);
         let __v_28: G = G::from_u64(0);
         let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_271] = [__v_29];
-        if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_272] = [__v_29];
+        if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
         let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
         let __v_27: G = G::from_u64(7);
         let __v_28: G = G::from_u64(0);
         let __v_29: G = G::from_u64(0);
         let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_271] = [__v_30];
-        if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_272] = [__v_30];
+        if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       7u64 => {
         let __v_23: G = G::from_u64(3);
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(0);
         let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_271] = [__v_27];
-        if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_272] = [__v_27];
+        if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       8u64 => {
         let __v_23: G = G::from_u64(4);
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(0);
         let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_271] = [__v_27];
-        if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_272] = [__v_27];
+        if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       9u64 => {
         let __v_23: G = G::from_u64(5);
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_9, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(0);
         let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_271] = [__v_27];
-        if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_272] = [__v_27];
+        if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       10u64 => {
         let __v_23: G = G::from_u64(6);
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
         let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_271] = [__v_27];
-        if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_272] = [__v_27];
+        if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       11u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
         let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
@@ -26119,10 +26138,10 @@ fn aiur_fn_271(
         let __v_27: G = __loaded[2];
         match __v_25.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
-            let __ret: [G; OUT_271] = [__v_28];
-            if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_272] = [__v_28];
+            if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -26137,15 +26156,15 @@ fn aiur_fn_271(
   })
 }
 
-const INPUT_SIZE_272: usize = 17;
-const IN_272: usize = 17;
-const OUT_272: usize = 12;
-fn aiur_fn_272(
-  inp: [G; IN_272],
+const INPUT_SIZE_273: usize = 17;
+const IN_273: usize = 17;
+const OUT_273: usize = 12;
+fn aiur_fn_273(
+  inp: [G; IN_273],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_272], ExecError> {
+) -> Result<[G; OUT_273], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26166,18 +26185,18 @@ fn aiur_fn_272(
     let __v_16: G = inp[16];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         match __v_0.as_canonical_u64() {
           0u64 => {
             let __v_20: G = G::from_u64(1);
             let __v_21: G = G::from_u64(0);
-            let __ret: [G; OUT_272] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
-            if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_273] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
+            if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
@@ -26195,15 +26214,15 @@ fn aiur_fn_272(
             let __v_20: G = __mc_out___mc_0[0];
             let __v_21: G = G::from_u64(3);
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_272] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22];
-            if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_273] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22];
+            if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           2u64 => {
             let __v_20: G = G::from_u64(2);
             let __v_21: G = G::from_u64(0);
-            let __ret: [G; OUT_272] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
-            if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_273] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
+            if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -26215,15 +26234,15 @@ fn aiur_fn_272(
   })
 }
 
-const INPUT_SIZE_273: usize = 14;
-const IN_273: usize = 14;
-const OUT_273: usize = 12;
-fn aiur_fn_273(
-  inp: [G; IN_273],
+const INPUT_SIZE_274: usize = 14;
+const IN_274: usize = 14;
+const OUT_274: usize = 12;
+fn aiur_fn_274(
+  inp: [G; IN_274],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_273], ExecError> {
+) -> Result<[G; OUT_274], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26241,29 +26260,29 @@ fn aiur_fn_273(
     let __v_13: G = inp[13];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __v_17: G = G::from_u64(0);
-        let __ret: [G; OUT_273] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
-        if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_274] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
+        if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_274: usize = 14;
-const IN_274: usize = 14;
-const OUT_274: usize = 12;
-fn aiur_fn_274(
-  inp: [G; IN_274],
+const INPUT_SIZE_275: usize = 14;
+const IN_275: usize = 14;
+const OUT_275: usize = 12;
+fn aiur_fn_275(
+  inp: [G; IN_275],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_274], ExecError> {
+) -> Result<[G; OUT_275], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26281,29 +26300,29 @@ fn aiur_fn_274(
     let __v_13: G = inp[13];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = G::from_u64(4);
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __v_17: G = G::from_u64(0);
-        let __ret: [G; OUT_274] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
-        if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_275] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
+        if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_275: usize = 1;
-const IN_275: usize = 1;
-const OUT_275: usize = 1;
-fn aiur_fn_275(
-  inp: [G; IN_275],
+const INPUT_SIZE_276: usize = 1;
+const IN_276: usize = 1;
+const OUT_276: usize = 1;
+fn aiur_fn_276(
+  inp: [G; IN_276],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_275], ExecError> {
+) -> Result<[G; OUT_276], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
@@ -26346,17 +26365,17 @@ fn aiur_fn_275(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_37: G = G::from_u64(0);
-        let __ret: [G; OUT_275] = [__v_37];
-        if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_276] = [__v_37];
+        if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
         let __v_38: G = G::from_u64(1);
         let __v_39: G = (__v_37 + __v_38);
-        let __ret: [G; OUT_275] = [__v_39];
-        if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_276] = [__v_39];
+        if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -26366,15 +26385,15 @@ fn aiur_fn_275(
   })
 }
 
-const INPUT_SIZE_276: usize = 2;
-const IN_276: usize = 2;
-const OUT_276: usize = 34;
-fn aiur_fn_276(
-  inp: [G; IN_276],
+const INPUT_SIZE_277: usize = 2;
+const IN_277: usize = 2;
+const OUT_277: usize = 34;
+fn aiur_fn_277(
+  inp: [G; IN_277],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_276], ExecError> {
+) -> Result<[G; OUT_277], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26419,14 +26438,14 @@ fn aiur_fn_276(
       0u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_276] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
-            if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_277] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+            if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_38: G = G::from_u64(1);
             let __v_39: G = (__v_1 - __v_38);
-            let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } };
             let __v_40: G = __r_arr[0];
             let __v_41: G = __r_arr[1];
             let __v_42: G = __r_arr[2];
@@ -26461,8 +26480,8 @@ fn aiur_fn_276(
             let __v_71: G = __r_arr[31];
             let __v_72: G = __r_arr[32];
             let __v_73: G = __r_arr[33];
-            let __ret: [G; OUT_276] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73];
-            if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_277] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73];
+            if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -26474,15 +26493,15 @@ fn aiur_fn_276(
   })
 }
 
-const INPUT_SIZE_277: usize = 33;
-const IN_277: usize = 33;
-const OUT_277: usize = 12;
-fn aiur_fn_277(
-  inp: [G; IN_277],
+const INPUT_SIZE_278: usize = 33;
+const IN_278: usize = 33;
+const OUT_278: usize = 12;
+fn aiur_fn_278(
+  inp: [G; IN_278],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_277], ExecError> {
+) -> Result<[G; OUT_278], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26519,35 +26538,35 @@ fn aiur_fn_277(
     let __v_32: G = inp[32];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_33: G = __r_arr[0];
         let __v_34: G = G::from_u64(5);
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_35: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__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[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_36: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
         let __v_38: G = __r_arr[0];
         let __v_39: G = G::from_u64(0);
-        let __ret: [G; OUT_277] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39];
-        if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_278] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39];
+        if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_278: usize = 40;
-const IN_278: usize = 40;
-const OUT_278: usize = 12;
-fn aiur_fn_278(
-  inp: [G; IN_278],
+const INPUT_SIZE_279: usize = 40;
+const IN_279: usize = 40;
+const OUT_279: usize = 12;
+fn aiur_fn_279(
+  inp: [G; IN_279],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_278], ExecError> {
+) -> Result<[G; OUT_279], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26591,35 +26610,35 @@ fn aiur_fn_278(
     let __v_39: G = inp[39];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_40: G = __r_arr[0];
         let __v_41: G = G::from_u64(6);
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_42: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__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[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_43: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_44: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_45: G = __r_arr[0];
         let __v_46: G = G::from_u64(0);
-        let __ret: [G; OUT_278] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46];
-        if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_279] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46];
+        if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_279: usize = 6;
-const IN_279: usize = 6;
-const OUT_279: usize = 1;
-fn aiur_fn_279(
-  inp: [G; IN_279],
+const INPUT_SIZE_280: usize = 6;
+const IN_280: usize = 6;
+const OUT_280: usize = 1;
+fn aiur_fn_280(
+  inp: [G; IN_280],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_279], ExecError> {
+) -> Result<[G; OUT_280], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26644,25 +26663,25 @@ fn aiur_fn_279(
         let __v_17: G = G::from_u64(1);
         let __v_18: G = G::from_u64(1);
         let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_279] = [__v_19];
-        if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_280] = [__v_19];
+        if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __v_18: G = G::from_u64(0);
-            let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
             let __v_19: G = __r_arr[0];
             let __v_20: G = G::from_u64(1);
             let __v_21: G = (__v_5 + __v_20);
-            let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
             let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_279] = [__v_23];
-            if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_280] = [__v_23];
+            if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -26674,15 +26693,15 @@ fn aiur_fn_279(
   })
 }
 
-const INPUT_SIZE_280: usize = 50;
-const IN_280: usize = 50;
-const OUT_280: usize = 12;
-fn aiur_fn_280(
-  inp: [G; IN_280],
+const INPUT_SIZE_281: usize = 50;
+const IN_281: usize = 50;
+const OUT_281: usize = 12;
+fn aiur_fn_281(
+  inp: [G; IN_281],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_280], ExecError> {
+) -> Result<[G; OUT_281], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26736,39 +26755,39 @@ fn aiur_fn_280(
     let __v_49: G = inp[49];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
         let __v_50: G = __r_arr[0];
         let __v_51: G = G::from_u64(0);
-        let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
         let __v_52: G = __r_arr[0];
         let __v_53: G = G::from_u64(7);
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_54: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__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[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__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[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_57: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_58: G = __r_arr[0];
-        let __ret: [G; OUT_280] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45];
-        if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_281] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45];
+        if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_281: usize = 1;
-const IN_281: usize = 1;
-const OUT_281: usize = 48;
-fn aiur_fn_281(
-  inp: [G; IN_281],
+const INPUT_SIZE_282: usize = 1;
+const IN_282: usize = 1;
+const OUT_282: usize = 48;
+fn aiur_fn_282(
+  inp: [G; IN_282],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_281], ExecError> {
+) -> Result<[G; OUT_282], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
@@ -26809,10 +26828,10 @@ fn aiur_fn_281(
     let __v_34: G = __io_pair.0;
     let __v_35: G = __io_pair.1;
     let __v_36: G = G::from_u64(2);
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } };
     let __v_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_20(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } } else { aiur_fn_20(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { 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_21] = { let __args: [G; IN_21] = [__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[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
     let __v_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -26877,21 +26896,21 @@ fn aiur_fn_281(
     if (__v_89 != __v_91) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_91.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) });
     }
-    let __ret: [G; OUT_281] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85];
-    if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_282] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85];
+    if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_282: usize = 1;
-const IN_282: usize = 1;
-const OUT_282: usize = 1;
-fn aiur_fn_282(
-  inp: [G; IN_282],
+const INPUT_SIZE_283: usize = 1;
+const IN_283: usize = 1;
+const OUT_283: usize = 1;
+fn aiur_fn_283(
+  inp: [G; IN_283],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_282], ExecError> {
+) -> Result<[G; OUT_283], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
@@ -26932,7 +26951,7 @@ fn aiur_fn_282(
     let __v_34: G = __io_pair.0;
     let __v_35: G = __io_pair.1;
     let __v_36: G = G::from_u64(3);
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } };
     let __v_37: G = __r_arr[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_38: G = __loaded[0];
@@ -26940,8 +26959,8 @@ fn aiur_fn_282(
     let __v_40: G = __loaded[2];
     match __v_38.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_282] = [__v_39];
-        if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_283] = [__v_39];
+        if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -26951,15 +26970,15 @@ fn aiur_fn_282(
   })
 }
 
-const INPUT_SIZE_283: usize = 1;
-const IN_283: usize = 1;
-const OUT_283: usize = 1;
-fn aiur_fn_283(
-  inp: [G; IN_283],
+const INPUT_SIZE_284: usize = 1;
+const IN_284: usize = 1;
+const OUT_284: usize = 1;
+fn aiur_fn_284(
+  inp: [G; IN_284],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_283], ExecError> {
+) -> Result<[G; OUT_284], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
@@ -27000,46 +27019,46 @@ fn aiur_fn_283(
     let __v_34: G = __io_pair.0;
     let __v_35: G = __io_pair.1;
     let __v_36: G = G::from_u64(4);
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } };
     let __v_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_20(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } } else { aiur_fn_20(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_283] = [__v_37];
-    if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__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[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_284] = [__v_37];
+    if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_284: usize = 2;
-const IN_284: usize = 2;
-const OUT_284: usize = 1;
-fn aiur_fn_284(
-  inp: [G; IN_284],
+const INPUT_SIZE_285: usize = 2;
+const IN_285: usize = 2;
+const OUT_285: usize = 1;
+fn aiur_fn_285(
+  inp: [G; IN_285],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_284], ExecError> {
+) -> Result<[G; OUT_285], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       2u64 => {
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_284] = [__v_2];
-        if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_285] = [__v_2];
+        if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(1);
-            let __ret: [G; OUT_284] = [__v_2];
-            if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_285] = [__v_2];
+            if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_2: G = G::from_u64(0);
-            let __ret: [G; OUT_284] = [__v_2];
-            if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_285] = [__v_2];
+            if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -27048,14 +27067,14 @@ fn aiur_fn_284(
         match __v_1.as_canonical_u64() {
           1u64 => {
             let __v_2: G = G::from_u64(0);
-            let __ret: [G; OUT_284] = [__v_2];
-            if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_285] = [__v_2];
+            if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_2: G = G::from_u64(1);
-            let __ret: [G; OUT_284] = [__v_2];
-            if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_285] = [__v_2];
+            if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -27067,15 +27086,15 @@ fn aiur_fn_284(
   })
 }
 
-const INPUT_SIZE_285: usize = 14;
-const IN_285: usize = 14;
-const OUT_285: usize = 1;
-fn aiur_fn_285(
-  inp: [G; IN_285],
+const INPUT_SIZE_286: usize = 14;
+const IN_286: usize = 14;
+const OUT_286: usize = 1;
+fn aiur_fn_286(
+  inp: [G; IN_286],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_285], ExecError> {
+) -> Result<[G; OUT_286], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -27093,22 +27112,22 @@ fn aiur_fn_285(
     let __v_13: G = inp[13];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         match __v_14.as_canonical_u64() {
           0u64 => {
             let __v_15: G = G::from_u64(1);
             let __v_16: G = G::from_u64(1);
             let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_285] = [__v_17];
-            if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_286] = [__v_17];
+            if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
-            let __ret: [G; OUT_285] = [__v_15];
-            if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_286] = [__v_15];
+            if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -27117,18 +27136,18 @@ fn aiur_fn_285(
   })
 }
 
-const INPUT_SIZE_286: usize = 1;
-const IN_286: usize = 1;
-const OUT_286: usize = 1;
-fn aiur_fn_286(
-  inp: [G; IN_286],
+const INPUT_SIZE_287: usize = 1;
+const IN_287: usize = 1;
+const OUT_287: usize = 1;
+fn aiur_fn_287(
+  inp: [G; IN_287],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_286], ExecError> {
+) -> Result<[G; OUT_287], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -27181,11 +27200,11 @@ fn aiur_fn_286(
       _ => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { 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_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
             let __v_49: G = __r_arr[0];
             let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
   _ => {
-    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
     let __v_50: G = __r_arr[0];
     match __v_50.as_canonical_u64() {
       0u64 => {
@@ -27207,7 +27226,7 @@ fn aiur_fn_286(
 }
  };
             let __v_50: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
             let __v_51: G = __r_arr[0];
             let __v_52: G = __r_arr[1];
             let __v_53: G = __r_arr[2];
@@ -27221,15 +27240,15 @@ fn aiur_fn_286(
             let __v_61: G = __r_arr[10];
             let __v_62: G = __r_arr[11];
             let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_286] = [__v_63];
-            if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_287] = [__v_63];
+            if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           2u64 => {
             let __v_49: G = G::from_u64(1);
             let __v_50: G = G::from_u64(1);
             let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
             let __v_52: G = __r_arr[0];
             let __v_53: G = __r_arr[1];
             let __v_54: G = __r_arr[2];
@@ -27243,15 +27262,15 @@ fn aiur_fn_286(
             let __v_62: G = __r_arr[10];
             let __v_63: G = __r_arr[11];
             let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_286] = [__v_64];
-            if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_287] = [__v_64];
+            if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           3u64 => {
             let __v_49: G = G::from_u64(1);
             let __v_50: G = G::from_u64(1);
             let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
             let __v_52: G = __r_arr[0];
             let __v_53: G = __r_arr[1];
             let __v_54: G = __r_arr[2];
@@ -27265,17 +27284,17 @@ fn aiur_fn_286(
             let __v_62: G = __r_arr[10];
             let __v_63: G = __r_arr[11];
             let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_286] = [__v_64];
-            if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_287] = [__v_64];
+            if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           7u64 => {
             match __v_2.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
                 let __v_49: G = __r_arr[0];
-                let __ret: [G; OUT_286] = [__v_49];
-                if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_287] = [__v_49];
+                if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -27283,12 +27302,12 @@ fn aiur_fn_286(
           6u64 => {
             match __v_2.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
                 let __v_50: G = __r_arr[0];
-                let __ret: [G; OUT_286] = [__v_50];
-                if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_287] = [__v_50];
+                if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -27296,14 +27315,14 @@ fn aiur_fn_286(
           4u64 => {
             match __v_2.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
                 let __v_51: G = __r_arr[0];
-                let __ret: [G; OUT_286] = [__v_51];
-                if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_287] = [__v_51];
+                if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -27311,12 +27330,12 @@ fn aiur_fn_286(
           5u64 => {
             match __v_2.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
                 let __v_50: G = __r_arr[0];
-                let __ret: [G; OUT_286] = [__v_50];
-                if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_287] = [__v_50];
+                if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -27328,7 +27347,7 @@ fn aiur_fn_286(
             let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_54: G = G::from_u64(0);
-            let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
             let __v_55: G = __r_arr[0];
             let __v_56: G = __r_arr[1];
             let __v_57: G = __r_arr[2];
@@ -27342,8 +27361,8 @@ fn aiur_fn_286(
             let __v_65: G = __r_arr[10];
             let __v_66: G = __r_arr[11];
             let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_286] = [__v_67];
-            if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_287] = [__v_67];
+            if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -27355,15 +27374,15 @@ fn aiur_fn_286(
   })
 }
 
-const INPUT_SIZE_287: usize = 10;
-const IN_287: usize = 10;
-const OUT_287: usize = 1;
-fn aiur_fn_287(
-  inp: [G; IN_287],
+const INPUT_SIZE_288: usize = 10;
+const IN_288: usize = 10;
+const OUT_288: usize = 1;
+fn aiur_fn_288(
+  inp: [G; IN_288],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_287], ExecError> {
+) -> Result<[G; OUT_288], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -27375,7 +27394,7 @@ fn aiur_fn_287(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -27476,11 +27495,11 @@ fn aiur_fn_287(
             let __v_102: G = __r_arr[44];
             match __v_58.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { 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_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
                 let __v_103: G = __r_arr[0];
-                let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
                 let __v_104: G = __r_arr[0];
-                let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
                 let __v_105: G = __r_arr[0];
                 let __v_106: G = __r_arr[1];
                 let __v_107: G = __r_arr[2];
@@ -27494,8 +27513,8 @@ fn aiur_fn_287(
                 let __v_115: G = __r_arr[10];
                 let __v_116: G = __r_arr[11];
                 let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_287] = [__v_117];
-                if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_288] = [__v_117];
+                if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -27512,19 +27531,19 @@ fn aiur_fn_287(
   })
 }
 
-const INPUT_SIZE_288: usize = 2;
-const IN_288: usize = 2;
-const OUT_288: usize = 1;
-fn aiur_fn_288(
-  inp: [G; IN_288],
+const INPUT_SIZE_289: usize = 2;
+const IN_289: usize = 2;
+const OUT_289: usize = 1;
+fn aiur_fn_289(
+  inp: [G; IN_289],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_288], ExecError> {
+) -> Result<[G; OUT_289], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -27577,7 +27596,7 @@ fn aiur_fn_288(
       _ => {
         match __v_2.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
             let __v_50: G = __r_arr[0];
             let __v_51: G = __r_arr[1];
             let __v_52: G = __r_arr[2];
@@ -27625,9 +27644,9 @@ fn aiur_fn_288(
             let __v_94: G = __r_arr[44];
             match __v_50.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
                 let __v_95: G = __r_arr[0];
-                let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
                 let __v_96: G = __r_arr[0];
                 let __v_97: G = __r_arr[1];
                 let __v_98: G = __r_arr[2];
@@ -27641,8 +27660,8 @@ fn aiur_fn_288(
                 let __v_106: G = __r_arr[10];
                 let __v_107: G = __r_arr[11];
                 let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_288] = [__v_108];
-                if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_289] = [__v_108];
+                if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -27659,20 +27678,20 @@ fn aiur_fn_288(
   })
 }
 
-const INPUT_SIZE_289: usize = 3;
-const IN_289: usize = 3;
-const OUT_289: usize = 1;
-fn aiur_fn_289(
-  inp: [G; IN_289],
+const INPUT_SIZE_290: usize = 3;
+const IN_290: usize = 3;
+const OUT_290: usize = 1;
+fn aiur_fn_290(
+  inp: [G; IN_290],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_289], ExecError> {
+) -> Result<[G; OUT_290], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -27725,7 +27744,7 @@ fn aiur_fn_289(
       _ => {
         match __v_3.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
             let __v_51: G = __r_arr[0];
             let __v_52: G = __r_arr[1];
             let __v_53: G = __r_arr[2];
@@ -27775,7 +27794,7 @@ fn aiur_fn_289(
               1u64 => {
                 match __v_52.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_78, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_78, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } };
                     let __v_96: G = __r_arr[0];
                     let __v_97: G = __r_arr[1];
                     let __v_98: G = __r_arr[2];
@@ -27810,9 +27829,9 @@ fn aiur_fn_289(
                     let __v_127: G = __r_arr[31];
                     let __v_128: G = __r_arr[32];
                     let __v_129: G = __r_arr[33];
-                    let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
                     let __v_130: G = __r_arr[0];
-                    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
                     let __v_131: G = __r_arr[0];
                     let __v_132: G = __r_arr[1];
                     let __v_133: G = __r_arr[2];
@@ -27826,8 +27845,8 @@ fn aiur_fn_289(
                     let __v_141: G = __r_arr[10];
                     let __v_142: G = __r_arr[11];
                     let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_289] = [__v_143];
-                    if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_290] = [__v_143];
+                    if let Some(result) = record.function_queries[290].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
@@ -27846,19 +27865,19 @@ fn aiur_fn_289(
   })
 }
 
-const INPUT_SIZE_290: usize = 2;
-const IN_290: usize = 2;
-const OUT_290: usize = 1;
-fn aiur_fn_290(
-  inp: [G; IN_290],
+const INPUT_SIZE_291: usize = 2;
+const IN_291: usize = 2;
+const OUT_291: usize = 1;
+fn aiur_fn_291(
+  inp: [G; IN_291],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_290], ExecError> {
+) -> Result<[G; OUT_291], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -27911,7 +27930,7 @@ fn aiur_fn_290(
       _ => {
         match __v_2.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
             let __v_50: G = __r_arr[0];
             let __v_51: G = __r_arr[1];
             let __v_52: G = __r_arr[2];
@@ -27959,9 +27978,9 @@ fn aiur_fn_290(
             let __v_94: G = __r_arr[44];
             match __v_50.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
                 let __v_95: G = __r_arr[0];
-                let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
                 let __v_96: G = __r_arr[0];
                 let __v_97: G = __r_arr[1];
                 let __v_98: G = __r_arr[2];
@@ -27975,8 +27994,8 @@ fn aiur_fn_290(
                 let __v_106: G = __r_arr[10];
                 let __v_107: G = __r_arr[11];
                 let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_290] = [__v_108];
-                if let Some(result) = record.function_queries[290].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_291] = [__v_108];
+                if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -27993,15 +28012,15 @@ fn aiur_fn_290(
   })
 }
 
-const INPUT_SIZE_291: usize = 2;
-const IN_291: usize = 2;
-const OUT_291: usize = 45;
-fn aiur_fn_291(
-  inp: [G; IN_291],
+const INPUT_SIZE_292: usize = 2;
+const IN_292: usize = 2;
+const OUT_292: usize = 45;
+fn aiur_fn_292(
+  inp: [G; IN_292],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_291], ExecError> {
+) -> Result<[G; OUT_292], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28057,14 +28076,14 @@ fn aiur_fn_291(
       0u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_291] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47];
-            if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_292] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47];
+            if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_49: G = G::from_u64(1);
             let __v_50: G = (__v_1 - __v_49);
-            let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
             let __v_51: G = __r_arr[0];
             let __v_52: G = __r_arr[1];
             let __v_53: G = __r_arr[2];
@@ -28110,8 +28129,8 @@ fn aiur_fn_291(
             let __v_93: G = __r_arr[42];
             let __v_94: G = __r_arr[43];
             let __v_95: G = __r_arr[44];
-            let __ret: [G; OUT_291] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95];
-            if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_292] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95];
+            if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -28123,15 +28142,15 @@ fn aiur_fn_291(
   })
 }
 
-const INPUT_SIZE_292: usize = 1;
-const IN_292: usize = 1;
-const OUT_292: usize = 8;
-fn aiur_fn_292(
-  inp: [G; IN_292],
+const INPUT_SIZE_293: usize = 1;
+const IN_293: usize = 1;
+const OUT_293: usize = 8;
+fn aiur_fn_293(
+  inp: [G; IN_293],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_292], ExecError> {
+) -> Result<[G; OUT_293], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes();
@@ -28147,31 +28166,31 @@ fn aiur_fn_292(
     if !unconstrained { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
     if !unconstrained { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
     if !unconstrained { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     if (__v_9 != __v_0) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection index bytes do not recompose to the index".to_string()) });
     }
-    let __ret: [G; OUT_292] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-    if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_293] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+    if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_293: usize = 3;
-const IN_293: usize = 3;
-const OUT_293: usize = 1;
-fn aiur_fn_293(
-  inp: [G; IN_293],
+const INPUT_SIZE_294: usize = 3;
+const IN_294: usize = 3;
+const OUT_294: usize = 1;
+fn aiur_fn_294(
+  inp: [G; IN_294],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_293], ExecError> {
+) -> Result<[G; OUT_294], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -28217,7 +28236,7 @@ fn aiur_fn_293(
     let __v_45: G = __r_arr[42];
     let __v_46: G = __r_arr[43];
     let __v_47: G = __r_arr[44];
-    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
     let __v_48: G = __r_arr[0];
     let __v_49: G = __r_arr[1];
     let __v_50: G = __r_arr[2];
@@ -28304,46 +28323,46 @@ fn aiur_fn_293(
     let __v_110: G = G::from_u64(1);
     let __v_111: G = G::from_u64(1);
     let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_111]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_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_103, __v_106, __v_109, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__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_103, __v_106, __v_109, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_113: G = __r_arr[0];
-    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_114: G = __r_arr[0];
-    let __ret: [G; OUT_293] = [__v_114];
-    if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_294] = [__v_114];
+    if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_294: usize = 2;
-const IN_294: usize = 2;
-const OUT_294: usize = 1;
-fn aiur_fn_294(
-  inp: [G; IN_294],
+const INPUT_SIZE_295: usize = 2;
+const IN_295: usize = 2;
+const OUT_295: usize = 1;
+fn aiur_fn_295(
+  inp: [G; IN_295],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_294], ExecError> {
+) -> Result<[G; OUT_295], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __ret: [G; OUT_294] = [__v_3];
-    if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_295] = [__v_3];
+    if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_295: usize = 4;
-const IN_295: usize = 4;
-const OUT_295: usize = 1;
-fn aiur_fn_295(
-  inp: [G; IN_295],
+const INPUT_SIZE_296: usize = 4;
+const IN_296: usize = 4;
+const OUT_296: usize = 1;
+fn aiur_fn_296(
+  inp: [G; IN_296],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_295], ExecError> {
+) -> Result<[G; OUT_296], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28402,21 +28421,21 @@ fn aiur_fn_295(
         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_295] = [__v_53];
-        if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_296] = [__v_53];
+        if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         let __v_51: G = G::from_u64(0);
-        let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
         let __v_52: G = __r_arr[0];
         let __v_53: G = G::from_u64(1);
         let __v_54: G = (__v_3 + __v_53);
-        let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
         let __v_55: G = __r_arr[0];
         let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_295] = [__v_56];
-        if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_296] = [__v_56];
+        if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -28426,15 +28445,15 @@ fn aiur_fn_295(
   })
 }
 
-const INPUT_SIZE_296: usize = 1;
-const IN_296: usize = 1;
-const OUT_296: usize = 1;
-fn aiur_fn_296(
-  inp: [G; IN_296],
+const INPUT_SIZE_297: usize = 1;
+const IN_297: usize = 1;
+const OUT_297: usize = 1;
+fn aiur_fn_297(
+  inp: [G; IN_297],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_296], ExecError> {
+) -> Result<[G; OUT_297], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -28444,57 +28463,57 @@ fn aiur_fn_296(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_296] = [__v_4];
-        if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_297] = [__v_4];
+        if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_296] = [__v_4];
-        if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_297] = [__v_4];
+        if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_296] = [__v_4];
-        if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_297] = [__v_4];
+        if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           0u64 => {
             match __v_5.as_canonical_u64() {
               0u64 => {
                 let __v_6: G = G::from_u64(0);
-                let __ret: [G; OUT_296] = [__v_6];
-                if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_297] = [__v_6];
+                if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_6: G = G::from_u64(1);
-                let __ret: [G; OUT_296] = [__v_6];
-                if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_297] = [__v_6];
+                if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_296] = [__v_6];
-            if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_297] = [__v_6];
+            if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_296] = [__v_4];
-        if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_297] = [__v_4];
+        if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -28504,15 +28523,15 @@ fn aiur_fn_296(
   })
 }
 
-const INPUT_SIZE_297: usize = 2;
-const IN_297: usize = 2;
-const OUT_297: usize = 1;
-fn aiur_fn_297(
-  inp: [G; IN_297],
+const INPUT_SIZE_298: usize = 2;
+const IN_298: usize = 2;
+const OUT_298: usize = 1;
+fn aiur_fn_298(
+  inp: [G; IN_298],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_297], ExecError> {
+) -> Result<[G; OUT_298], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28529,14 +28548,14 @@ fn aiur_fn_297(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_297] = [__v_8];
-            if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_298] = [__v_8];
+            if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_297] = [__v_8];
-            if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_298] = [__v_8];
+            if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -28548,16 +28567,16 @@ fn aiur_fn_297(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_297] = [__v_8];
-            if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_298] = [__v_8];
+            if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_297] = [__v_8];
-            if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_298] = [__v_8];
+            if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -28569,19 +28588,19 @@ fn aiur_fn_297(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = (__v_8 * __v_9);
-            let __ret: [G; OUT_297] = [__v_10];
-            if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_298] = [__v_10];
+            if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_297] = [__v_8];
-            if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_298] = [__v_8];
+            if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -28593,19 +28612,19 @@ fn aiur_fn_297(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = (__v_8 * __v_9);
-            let __ret: [G; OUT_297] = [__v_10];
-            if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_298] = [__v_10];
+            if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_297] = [__v_8];
-            if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_298] = [__v_8];
+            if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -28619,14 +28638,14 @@ fn aiur_fn_297(
           4u64 => {
             let __v_8: G = (__v_3 - __v_6);
             let __v_9: G = G::from_bool((__v_8 == G::ZERO));
-            let __ret: [G; OUT_297] = [__v_9];
-            if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_298] = [__v_9];
+            if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_297] = [__v_8];
-            if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_298] = [__v_8];
+            if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -28638,15 +28657,15 @@ fn aiur_fn_297(
   })
 }
 
-const INPUT_SIZE_298: usize = 2;
-const IN_298: usize = 2;
-const OUT_298: usize = 1;
-fn aiur_fn_298(
-  inp: [G; IN_298],
+const INPUT_SIZE_299: usize = 2;
+const IN_299: usize = 2;
+const OUT_299: usize = 1;
+fn aiur_fn_299(
+  inp: [G; IN_299],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_298], ExecError> {
+) -> Result<[G; OUT_299], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28663,14 +28682,14 @@ fn aiur_fn_298(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_298] = [__v_8];
-            if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_299] = [__v_8];
+            if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_298] = [__v_8];
-            if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_299] = [__v_8];
+            if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -28686,8 +28705,8 @@ fn aiur_fn_298(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_298] = [__v_8];
-            if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_299] = [__v_8];
+            if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
@@ -28695,8 +28714,8 @@ fn aiur_fn_298(
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_9: G = G::from_u64(1);
-                let __ret: [G; OUT_298] = [__v_9];
-                if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_299] = [__v_9];
+                if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               0u64 => {
@@ -28704,15 +28723,15 @@ fn aiur_fn_298(
                 match __v_9.as_canonical_u64() {
                   1u64 => {
                     let __v_10: G = G::from_u64(2);
-                    let __ret: [G; OUT_298] = [__v_10];
-                    if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_299] = [__v_10];
+                    if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_298] = [__v_10];
-                    if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_299] = [__v_10];
+                    if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -28737,15 +28756,15 @@ fn aiur_fn_298(
   })
 }
 
-const INPUT_SIZE_299: usize = 2;
-const IN_299: usize = 2;
-const OUT_299: usize = 1;
-fn aiur_fn_299(
-  inp: [G; IN_299],
+const INPUT_SIZE_300: usize = 2;
+const IN_300: usize = 2;
+const OUT_300: usize = 1;
+fn aiur_fn_300(
+  inp: [G; IN_300],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_299], ExecError> {
+) -> Result<[G; OUT_300], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28756,8 +28775,8 @@ fn aiur_fn_299(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_299] = [__v_5];
-        if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_300] = [__v_5];
+        if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -28768,8 +28787,8 @@ fn aiur_fn_299(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_299] = [__v_8];
-            if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_300] = [__v_8];
+            if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
@@ -28777,25 +28796,25 @@ fn aiur_fn_299(
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_299] = [__v_9];
-                if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_300] = [__v_9];
+                if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
                 match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_299] = [__v_10];
-                    if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_300] = [__v_10];
+                    if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_299] = [__v_10];
-                    if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_300] = [__v_10];
+                    if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -28820,15 +28839,15 @@ fn aiur_fn_299(
   })
 }
 
-const INPUT_SIZE_300: usize = 2;
-const IN_300: usize = 2;
-const OUT_300: usize = 1;
-fn aiur_fn_300(
-  inp: [G; IN_300],
+const INPUT_SIZE_301: usize = 2;
+const IN_301: usize = 2;
+const OUT_301: usize = 1;
+fn aiur_fn_301(
+  inp: [G; IN_301],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_300], ExecError> {
+) -> Result<[G; OUT_301], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28845,14 +28864,14 @@ fn aiur_fn_300(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_300] = [__v_8];
-            if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_301] = [__v_8];
+            if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_300] = [__v_8];
-            if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_301] = [__v_8];
+            if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -28868,15 +28887,15 @@ fn aiur_fn_300(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_300] = [__v_8];
-            if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_301] = [__v_8];
+            if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_300] = [__v_8];
-            if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_301] = [__v_8];
+            if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -28891,15 +28910,15 @@ fn aiur_fn_300(
   })
 }
 
-const INPUT_SIZE_301: usize = 2;
-const IN_301: usize = 2;
-const OUT_301: usize = 2;
-fn aiur_fn_301(
-  inp: [G; IN_301],
+const INPUT_SIZE_302: usize = 2;
+const IN_302: usize = 2;
+const OUT_302: usize = 2;
+fn aiur_fn_302(
+  inp: [G; IN_302],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_301], ExecError> {
+) -> Result<[G; OUT_302], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28915,8 +28934,8 @@ fn aiur_fn_301(
         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_301] = [__v_5, __v_10];
-        if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_302] = [__v_5, __v_10];
+        if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -28926,8 +28945,8 @@ fn aiur_fn_301(
             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_301] = [__v_6, __v_8];
-            if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_302] = [__v_6, __v_8];
+            if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
@@ -28935,18 +28954,18 @@ fn aiur_fn_301(
             match __v_6.as_canonical_u64() {
               0u64 => {
                 let __v_7: G = G::from_u64(0);
-                let __ret: [G; OUT_301] = [__v_7, __v_1];
-                if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_302] = [__v_7, __v_1];
+                if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
                 let __v_8: G = __r_arr[1];
                 let __v_9: G = G::from_u64(0);
                 let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_301] = [__v_7, __v_10];
-                if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_302] = [__v_7, __v_10];
+                if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -28966,15 +28985,15 @@ fn aiur_fn_301(
   })
 }
 
-const INPUT_SIZE_302: usize = 3;
-const IN_302: usize = 3;
-const OUT_302: usize = 1;
-fn aiur_fn_302(
-  inp: [G; IN_302],
+const INPUT_SIZE_303: usize = 3;
+const IN_303: usize = 3;
+const OUT_303: usize = 1;
+fn aiur_fn_303(
+  inp: [G; IN_303],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_302], ExecError> {
+) -> Result<[G; OUT_303], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28991,8 +29010,8 @@ fn aiur_fn_302(
         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_302] = [__v_11];
-        if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_303] = [__v_11];
+        if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -29007,8 +29026,8 @@ fn aiur_fn_302(
                 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_302] = [__v_11];
-                if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_303] = [__v_11];
+                if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               0u64 => {
@@ -29016,11 +29035,11 @@ fn aiur_fn_302(
                 match __v_9.as_canonical_u64() {
                   1u64 => {
                     let __v_10: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
                     let __v_11: G = __r_arr[0];
                     let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_302] = [__v_12];
-                    if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_303] = [__v_12];
+                    if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   0u64 => {
@@ -29030,13 +29049,13 @@ fn aiur_fn_302(
                         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_302] = [__v_13];
-                        if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_303] = [__v_13];
+                        if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __ret: [G; OUT_302] = [__v_0];
-                        if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_303] = [__v_0];
+                        if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       _ => {
@@ -29063,15 +29082,15 @@ fn aiur_fn_302(
   })
 }
 
-const INPUT_SIZE_303: usize = 2;
-const IN_303: usize = 2;
-const OUT_303: usize = 1;
-fn aiur_fn_303(
-  inp: [G; IN_303],
+const INPUT_SIZE_304: usize = 2;
+const IN_304: usize = 2;
+const OUT_304: usize = 1;
+fn aiur_fn_304(
+  inp: [G; IN_304],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_303], ExecError> {
+) -> Result<[G; OUT_304], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29088,14 +29107,14 @@ fn aiur_fn_303(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_303] = [__v_8];
-            if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_304] = [__v_8];
+            if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_303] = [__v_8];
-            if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_304] = [__v_8];
+            if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -29111,8 +29130,8 @@ fn aiur_fn_303(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_303] = [__v_8];
-            if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_304] = [__v_8];
+            if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
@@ -29132,24 +29151,24 @@ fn aiur_fn_303(
                         let __v_13: G = (__v_9 - __v_11);
                         match __v_13.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
                             let __v_14: G = __r_arr[0];
-                            let __ret: [G; OUT_303] = [__v_14];
-                            if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_304] = [__v_14];
+                            if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_14: G = G::from_u64(0);
-                            let __ret: [G; OUT_303] = [__v_14];
-                            if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_304] = [__v_14];
+                            if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_13: G = G::from_u64(0);
-                        let __ret: [G; OUT_303] = [__v_13];
-                        if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_304] = [__v_13];
+                        if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
@@ -29170,15 +29189,15 @@ fn aiur_fn_303(
   })
 }
 
-const INPUT_SIZE_304: usize = 1;
-const IN_304: usize = 1;
-const OUT_304: usize = 1;
-fn aiur_fn_304(
-  inp: [G; IN_304],
+const INPUT_SIZE_305: usize = 1;
+const IN_305: usize = 1;
+const OUT_305: usize = 1;
+fn aiur_fn_305(
+  inp: [G; IN_305],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_304], ExecError> {
+) -> Result<[G; OUT_305], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -29188,8 +29207,8 @@ fn aiur_fn_304(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_304] = [__v_4];
-        if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_305] = [__v_4];
+        if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -29198,18 +29217,18 @@ fn aiur_fn_304(
         let __v_5: G = __loaded[1];
         match __v_4.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             let __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
             match __v_7.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_304] = [__v_5];
-                if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_305] = [__v_5];
+                if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               0u64 => {
-                let __ret: [G; OUT_304] = [__v_6];
-                if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_305] = [__v_6];
+                if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -29226,15 +29245,15 @@ fn aiur_fn_304(
   })
 }
 
-const INPUT_SIZE_305: usize = 2;
-const IN_305: usize = 2;
-const OUT_305: usize = 1;
-fn aiur_fn_305(
-  inp: [G; IN_305],
+const INPUT_SIZE_306: usize = 2;
+const IN_306: usize = 2;
+const OUT_306: usize = 1;
+fn aiur_fn_306(
+  inp: [G; IN_306],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_305], ExecError> {
+) -> Result<[G; OUT_306], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29244,8 +29263,8 @@ fn aiur_fn_305(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_305] = [__v_0];
-        if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_306] = [__v_0];
+        if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -29255,8 +29274,8 @@ fn aiur_fn_305(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_305] = [__v_0];
-            if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_306] = [__v_0];
+            if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
@@ -29274,21 +29293,21 @@ fn aiur_fn_305(
                     match __v_12.as_canonical_u64() {
                       1u64 => {
                         let __v_13: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
                         let __v_14: G = __r_arr[0];
                         let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_305] = [__v_15];
-                        if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_306] = [__v_15];
+                        if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       0u64 => {
                         let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
                         match __v_13.as_canonical_u64() {
                           1u64 => {
-                            let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
                             let __v_14: G = __r_arr[0];
-                            let __ret: [G; OUT_305] = [__v_14];
-                            if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_306] = [__v_14];
+                            if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                           0u64 => {
@@ -29296,18 +29315,18 @@ fn aiur_fn_305(
                             match __v_14.as_canonical_u64() {
                               1u64 => {
                                 let __v_15: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
                                 let __v_16: G = __r_arr[0];
                                 let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_305] = [__v_17];
-                                if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_306] = [__v_17];
+                                if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               0u64 => {
-                                let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
                                 let __v_15: G = __r_arr[0];
-                                let __ret: [G; OUT_305] = [__v_15];
-                                if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_306] = [__v_15];
+                                if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
@@ -29341,23 +29360,23 @@ 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_307: usize = 3;
+const IN_307: usize = 3;
+const OUT_307: usize = 1;
+fn aiur_fn_307(
+  inp: [G; IN_307],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_306], ExecError> {
+) -> Result<[G; OUT_307], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_306] = [__v_0];
-        if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_307] = [__v_0];
+        if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
@@ -29367,15 +29386,15 @@ fn aiur_fn_306(
         let __v_5: G = __loaded[2];
         match __v_3.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_306] = [__v_6];
-            if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_307] = [__v_6];
+            if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
-            let __ret: [G; OUT_306] = [__v_0];
-            if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_307] = [__v_0];
+            if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -29384,25 +29403,25 @@ fn aiur_fn_306(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __ret: [G; OUT_306] = [__v_3];
-        if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_307] = [__v_3];
+        if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_307: usize = 3;
-const IN_307: usize = 3;
-const OUT_307: usize = 1;
-fn aiur_fn_307(
-  inp: [G; IN_307],
+const INPUT_SIZE_308: usize = 3;
+const IN_308: usize = 3;
+const OUT_308: usize = 1;
+fn aiur_fn_308(
+  inp: [G; IN_308],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_307], ExecError> {
+) -> Result<[G; OUT_308], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29422,8 +29441,8 @@ fn aiur_fn_307(
         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_307] = [__v_14];
-        if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_308] = [__v_14];
+        if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -29433,7 +29452,7 @@ fn aiur_fn_307(
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               0u64 => {
@@ -29443,13 +29462,13 @@ fn aiur_fn_307(
                     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_307] = [__v_13];
-                    if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_308] = [__v_13];
+                    if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __ret: [G; OUT_307] = [__v_0];
-                    if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_308] = [__v_0];
+                    if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -29464,17 +29483,17 @@ fn aiur_fn_307(
                 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_307] = [__v_15];
-                if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_308] = [__v_15];
+                if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_307] = [__v_12];
-                if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_308] = [__v_12];
+                if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -29488,15 +29507,15 @@ fn aiur_fn_307(
   })
 }
 
-const INPUT_SIZE_308: usize = 4;
-const IN_308: usize = 4;
-const OUT_308: usize = 1;
-fn aiur_fn_308(
-  inp: [G; IN_308],
+const INPUT_SIZE_309: usize = 4;
+const IN_309: usize = 4;
+const OUT_309: usize = 1;
+fn aiur_fn_309(
+  inp: [G; IN_309],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_308], 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];
@@ -29521,8 +29540,8 @@ fn aiur_fn_308(
         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_308] = [__v_19];
-        if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_309] = [__v_19];
+        if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -29532,17 +29551,17 @@ fn aiur_fn_308(
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               0u64 => {
                 let __v_11: G = G::from_u64(0);
-                let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
                 let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_308] = [__v_14];
-                if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_309] = [__v_14];
+                if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               1u64 => {
@@ -29556,17 +29575,17 @@ fn aiur_fn_308(
                 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_308] = [__v_20];
-                if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_309] = [__v_20];
+                if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
                 let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_308] = [__v_13];
-                if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_309] = [__v_13];
+                if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -29580,15 +29599,15 @@ fn aiur_fn_308(
   })
 }
 
-const INPUT_SIZE_309: usize = 4;
-const IN_309: usize = 4;
-const OUT_309: usize = 1;
-fn aiur_fn_309(
-  inp: [G; IN_309],
+const INPUT_SIZE_310: usize = 4;
+const IN_310: usize = 4;
+const OUT_310: usize = 1;
+fn aiur_fn_310(
+  inp: [G; IN_310],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_309], 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];
@@ -29600,63 +29619,63 @@ fn aiur_fn_309(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_309] = [__v_7];
-        if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_310] = [__v_7];
+        if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_2 + __v_7);
-        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_309] = [__v_9];
-        if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_310] = [__v_9];
+        if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_309] = [__v_8];
-        if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_310] = [__v_8];
+        if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_309] = [__v_7];
-        if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_310] = [__v_7];
+        if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_309] = [__v_10];
-            if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_310] = [__v_10];
+            if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
             match __v_2.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_309] = [__v_3];
-                if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_310] = [__v_3];
+                if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_309] = [__v_9];
-                if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_310] = [__v_9];
+                if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -29673,15 +29692,15 @@ fn aiur_fn_309(
   })
 }
 
-const INPUT_SIZE_310: usize = 5;
-const IN_310: usize = 5;
-const OUT_310: usize = 1;
-fn aiur_fn_310(
-  inp: [G; IN_310],
+const INPUT_SIZE_311: usize = 5;
+const IN_311: usize = 5;
+const OUT_311: usize = 1;
+fn aiur_fn_311(
+  inp: [G; IN_311],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_310], 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];
@@ -29694,55 +29713,55 @@ fn aiur_fn_310(
     let __v_7: G = __loaded[2];
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_310] = [__v_8];
-        if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_311] = [__v_8];
+        if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_3 + __v_8);
-        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_310] = [__v_11];
-        if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_311] = [__v_11];
+        if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_310] = [__v_9];
-        if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_311] = [__v_9];
+        if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_310] = [__v_9];
-        if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_311] = [__v_9];
+        if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_310] = [__v_12];
-            if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_311] = [__v_12];
+            if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
@@ -29751,17 +29770,17 @@ fn aiur_fn_310(
     break '__mc_0 [__v_4];
   },
   _ => {
-    let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     break '__mc_0 [__v_10];
   },
 }
  };
             let __v_10: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_310] = [__v_11];
-            if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_311] = [__v_11];
+            if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -29776,15 +29795,15 @@ 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_312: usize = 2;
+const IN_312: usize = 2;
+const OUT_312: usize = 1;
+fn aiur_fn_312(
+  inp: [G; IN_312],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_311], 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];
@@ -29794,19 +29813,19 @@ fn aiur_fn_311(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_311] = [__v_0];
-        if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_312] = [__v_0];
+        if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_311] = [__v_8];
-        if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_312] = [__v_8];
+        if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -29816,15 +29835,15 @@ fn aiur_fn_311(
   })
 }
 
-const INPUT_SIZE_312: usize = 2;
-const IN_312: usize = 2;
-const OUT_312: usize = 1;
-fn aiur_fn_312(
-  inp: [G; IN_312],
+const INPUT_SIZE_313: usize = 2;
+const IN_313: usize = 2;
+const OUT_313: usize = 1;
+fn aiur_fn_313(
+  inp: [G; IN_313],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_312], ExecError> {
+) -> Result<[G; OUT_313], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29834,8 +29853,8 @@ fn aiur_fn_312(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_312] = [__v_0];
-        if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_313] = [__v_0];
+        if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -29851,18 +29870,18 @@ fn aiur_fn_312(
             let __v_10: G = __loaded[2];
             match __v_8.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   0u64 => {
-                    let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
-                    let __ret: [G; OUT_312] = [__v_12];
-                    if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_313] = [__v_12];
+                    if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
                     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() {
   0u64 => {
@@ -29895,7 +29914,7 @@ fn aiur_fn_312(
     break '__mc_2 [__v_17];
   },
   0u64 => {
-    let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
     let __v_17: G = __r_arr[0];
     let __v_18: G = G::from_u64(1);
     let __v_19: G = (__v_17 + __v_18);
@@ -29936,7 +29955,7 @@ fn aiur_fn_312(
         break '__mc_3 [__v_7];
       },
       0u64 => {
-        let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
         let __v_17: G = __r_arr[0];
         break '__mc_3 [__v_17];
       },
@@ -29952,10 +29971,10 @@ fn aiur_fn_312(
  };
                     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_312] = { let __args: [G; IN_312] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
                     let __v_16: G = __r_arr[0];
-                    let __ret: [G; OUT_312] = [__v_16];
-                    if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_313] = [__v_16];
+                    if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
@@ -29971,15 +29990,15 @@ fn aiur_fn_312(
   })
 }
 
-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_314: usize = 1;
+const IN_314: usize = 1;
+const OUT_314: usize = 1;
+fn aiur_fn_314(
+  inp: [G; IN_314],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_313], ExecError> {
+) -> Result<[G; OUT_314], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -29988,8 +30007,8 @@ fn aiur_fn_313(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_313] = [__v_0];
-        if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_314] = [__v_0];
+        if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -30007,15 +30026,15 @@ fn aiur_fn_313(
                 let __v_9: G = __loaded[2];
                 match __v_7.as_canonical_u64() {
                   1u64 => {
-                    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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_313] = [__v_10];
-                    if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_314] = [__v_10];
+                    if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __ret: [G; OUT_313] = [__v_0];
-                    if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_314] = [__v_0];
+                    if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -30024,8 +30043,8 @@ fn aiur_fn_313(
                 }
               },
               _ => {
-                let __ret: [G; OUT_313] = [__v_0];
-                if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_314] = [__v_0];
+                if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -30039,21 +30058,21 @@ fn aiur_fn_313(
   })
 }
 
-const INPUT_SIZE_314: usize = 2;
-const IN_314: usize = 2;
-const OUT_314: usize = 1;
-fn aiur_fn_314(
-  inp: [G; IN_314],
+const INPUT_SIZE_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_314], 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_313] = { let __args: [G; IN_313] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
@@ -30068,14 +30087,14 @@ fn aiur_fn_314(
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_10: G = G::from_u64(1);
-            let __ret: [G; OUT_314] = [__v_10];
-            if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_315] = [__v_10];
+            if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_314] = [__v_10];
-            if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_315] = [__v_10];
+            if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -30091,8 +30110,8 @@ fn aiur_fn_314(
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_314] = [__v_10];
-            if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_315] = [__v_10];
+            if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
@@ -30108,27 +30127,27 @@ fn aiur_fn_314(
                 let __v_15: G = __loaded[2];
                 match __v_13.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
                     let __v_16: G = __r_arr[0];
                     match __v_16.as_canonical_u64() {
                       0u64 => {
                         let __v_17: G = (__v_11 - __v_14);
                         match __v_17.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
                             let __v_18: G = __r_arr[0];
                             match __v_18.as_canonical_u64() {
                               1u64 => {
-                                let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } };
                                 let __v_19: G = __r_arr[0];
-                                let __ret: [G; OUT_314] = [__v_19];
-                                if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_315] = [__v_19];
+                                if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               0u64 => {
                                 let __v_19: G = G::from_u64(0);
-                                let __ret: [G; OUT_314] = [__v_19];
-                                if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_315] = [__v_19];
+                                if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                               _ => {
@@ -30138,16 +30157,16 @@ fn aiur_fn_314(
                           },
                           _ => {
                             let __v_18: G = G::from_u64(0);
-                            let __ret: [G; OUT_314] = [__v_18];
-                            if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_315] = [__v_18];
+                            if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_17: G = G::from_u64(0);
-                        let __ret: [G; OUT_314] = [__v_17];
-                        if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_315] = [__v_17];
+                        if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
@@ -30168,15 +30187,15 @@ fn aiur_fn_314(
   })
 }
 
-const INPUT_SIZE_315: usize = 3;
-const IN_315: usize = 3;
-const OUT_315: usize = 1;
-fn aiur_fn_315(
-  inp: [G; IN_315],
+const INPUT_SIZE_316: usize = 3;
+const IN_316: usize = 3;
+const OUT_316: usize = 1;
+fn aiur_fn_316(
+  inp: [G; IN_316],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_315], ExecError> {
+) -> Result<[G; OUT_316], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30188,8 +30207,8 @@ fn aiur_fn_315(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_315] = [__v_6];
-        if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_316] = [__v_6];
+        if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -30199,14 +30218,14 @@ fn aiur_fn_315(
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_315] = [__v_10];
-                if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_316] = [__v_10];
+                if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -30217,7 +30236,7 @@ fn aiur_fn_315(
     break '__mc_0 [__v_11];
   },
   1u64 => {
-    let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     break '__mc_0 [__v_11];
   },
@@ -30230,15 +30249,15 @@ fn aiur_fn_315(
                 match __v_11.as_canonical_u64() {
                   1u64 => {
                     let __v_12: G = G::from_u64(1);
-                    let __ret: [G; OUT_315] = [__v_12];
-                    if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_316] = [__v_12];
+                    if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
-                    let __ret: [G; OUT_315] = [__v_12];
-                    if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_316] = [__v_12];
+                    if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -30257,15 +30276,15 @@ fn aiur_fn_315(
   })
 }
 
-const INPUT_SIZE_316: usize = 2;
-const IN_316: usize = 2;
-const OUT_316: usize = 1;
-fn aiur_fn_316(
-  inp: [G; IN_316],
+const INPUT_SIZE_317: usize = 2;
+const IN_317: usize = 2;
+const OUT_317: usize = 1;
+fn aiur_fn_317(
+  inp: [G; IN_317],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_316], 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];
@@ -30276,8 +30295,8 @@ fn aiur_fn_316(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_316] = [__v_5];
-        if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_317] = [__v_5];
+        if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -30292,15 +30311,15 @@ fn aiur_fn_316(
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_316] = [__v_10];
-                if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_317] = [__v_10];
+                if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_316] = [__v_10];
-                if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_317] = [__v_10];
+                if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -30317,15 +30336,15 @@ fn aiur_fn_316(
   })
 }
 
-const INPUT_SIZE_317: usize = 4;
-const IN_317: usize = 4;
-const OUT_317: usize = 1;
-fn aiur_fn_317(
-  inp: [G; IN_317],
+const INPUT_SIZE_318: usize = 4;
+const IN_318: usize = 4;
+const OUT_318: usize = 1;
+fn aiur_fn_318(
+  inp: [G; IN_318],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_317], ExecError> {
+) -> Result<[G; OUT_318], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30338,8 +30357,8 @@ fn aiur_fn_317(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_317] = [__v_7];
-        if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_318] = [__v_7];
+        if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -30349,31 +30368,31 @@ fn aiur_fn_317(
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_317] = [__v_11];
-                if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_318] = [__v_11];
+                if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
                     let __v_12: G = G::from_u64(1);
-                    let __ret: [G; OUT_317] = [__v_12];
-                    if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_318] = [__v_12];
+                    if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
-                    let __ret: [G; OUT_317] = [__v_12];
-                    if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_318] = [__v_12];
+                    if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -30392,15 +30411,15 @@ fn aiur_fn_317(
   })
 }
 
-const INPUT_SIZE_318: usize = 3;
-const IN_318: usize = 3;
-const OUT_318: usize = 1;
-fn aiur_fn_318(
-  inp: [G; IN_318],
+const INPUT_SIZE_319: usize = 3;
+const IN_319: usize = 3;
+const OUT_319: usize = 1;
+fn aiur_fn_319(
+  inp: [G; IN_319],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_318], 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];
@@ -30412,8 +30431,8 @@ fn aiur_fn_318(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_318] = [__v_6];
-        if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_319] = [__v_6];
+        if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -30429,15 +30448,15 @@ fn aiur_fn_318(
                 match __v_9.as_canonical_u64() {
                   0u64 => {
                     let __v_10: G = G::from_u64(1);
-                    let __ret: [G; OUT_318] = [__v_10];
-                    if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_319] = [__v_10];
+                    if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_318] = [__v_10];
-                    if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_319] = [__v_10];
+                    if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -30446,10 +30465,10 @@ fn aiur_fn_318(
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_318] = [__v_9];
-                if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_319] = [__v_9];
+                if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -30463,15 +30482,15 @@ fn aiur_fn_318(
   })
 }
 
-const INPUT_SIZE_319: usize = 2;
-const IN_319: usize = 2;
-const OUT_319: usize = 1;
-fn aiur_fn_319(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_319], 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];
@@ -30482,8 +30501,8 @@ fn aiur_fn_319(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_319] = [__v_5];
-        if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_320] = [__v_5];
+        if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -30499,7 +30518,7 @@ fn aiur_fn_319(
     break '__mc_0 [__v_8];
   },
   _ => {
-    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     break '__mc_0 [__v_8];
   },
@@ -30509,25 +30528,25 @@ fn aiur_fn_319(
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_319] = [__v_9];
-                if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_320] = [__v_9];
+                if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
                 match __v_9.as_canonical_u64() {
                   0u64 => {
                     let __v_10: G = G::from_u64(0);
-                    let __ret: [G; OUT_319] = [__v_10];
-                    if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_320] = [__v_10];
+                    if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_319] = [__v_10];
-                    if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_320] = [__v_10];
+                    if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -30549,15 +30568,15 @@ fn aiur_fn_319(
   })
 }
 
-const INPUT_SIZE_320: usize = 3;
-const IN_320: usize = 3;
-const OUT_320: usize = 1;
-fn aiur_fn_320(
-  inp: [G; IN_320],
+const INPUT_SIZE_321: usize = 3;
+const IN_321: usize = 3;
+const OUT_321: usize = 1;
+fn aiur_fn_321(
+  inp: [G; IN_321],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_320], 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];
@@ -30569,8 +30588,8 @@ fn aiur_fn_320(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_320] = [__v_6];
-        if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_321] = [__v_6];
+        if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -30579,20 +30598,20 @@ fn aiur_fn_320(
         let __v_7: G = __loaded[1];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_320] = [__v_9];
-                if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_321] = [__v_9];
+                if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_320] = [__v_9];
-                if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_321] = [__v_9];
+                if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -30609,15 +30628,15 @@ fn aiur_fn_320(
   })
 }
 
-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_322: usize = 1;
+const IN_322: usize = 1;
+const OUT_322: usize = 1;
+fn aiur_fn_322(
+  inp: [G; IN_322],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_321], ExecError> {
+) -> Result<[G; OUT_322], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -30637,69 +30656,16 @@ fn aiur_fn_321(
     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_309] = { let __args: [G; IN_309] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
-    let __ret: [G; OUT_321] = [__v_19];
-    if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_322] = [__v_19];
+    if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_322: usize = 2;
-const IN_322: usize = 2;
-const OUT_322: usize = 1;
-fn aiur_fn_322(
-  inp: [G; IN_322],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_322], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_322] = [__v_3];
-        if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_3: G = __loaded[0];
-        let __v_4: G = __loaded[1];
-        let __v_5: G = __loaded[2];
-        match __v_3.as_canonical_u64() {
-          0u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_322] = [__v_6];
-            if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_322] = [__v_8];
-            if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
 const INPUT_SIZE_323: usize = 2;
 const IN_323: usize = 2;
 const OUT_323: usize = 1;
@@ -30712,7 +30678,7 @@ fn aiur_fn_323(
   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_297] = { let __args: [G; IN_297] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
@@ -30722,15 +30688,29 @@ fn aiur_fn_323(
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_323] = [__v_5];
-        if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        match __v_3.as_canonical_u64() {
+          0u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __ret: [G; OUT_323] = [__v_6];
+            if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __ret: [G; OUT_323] = [__v_8];
+            if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
       },
       _ => {
         return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
@@ -30751,12 +30731,51 @@ fn aiur_fn_324(
   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_329] = { let __args: [G; IN_329] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_324] = [__v_3];
+        if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __ret: [G; OUT_324] = [__v_5];
+        if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_325: usize = 2;
+const IN_325: usize = 2;
+const OUT_325: usize = 1;
+fn aiur_fn_325(
+  inp: [G; IN_325],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_325], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
         match __v_4.as_canonical_u64() {
@@ -30764,13 +30783,13 @@ fn aiur_fn_324(
             let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
             match __v_6.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_324] = [__v_1];
-                if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_325] = [__v_1];
+                if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               0u64 => {
-                let __ret: [G; OUT_324] = [__v_0];
-                if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_325] = [__v_0];
+                if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -30779,43 +30798,43 @@ fn aiur_fn_324(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_324] = [__v_6];
-            if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_325] = [__v_6];
+            if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_324] = [__v_4];
-        if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_325] = [__v_4];
+        if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_325: usize = 2;
-const IN_325: usize = 2;
-const OUT_325: usize = 1;
-fn aiur_fn_325(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_325], 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_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_325] = [__v_0];
-        if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_326] = [__v_0];
+        if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -30825,8 +30844,8 @@ fn aiur_fn_325(
         let __v_5: G = __loaded[2];
         match __v_3.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_325] = [__v_1];
-            if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_326] = [__v_1];
+            if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -30836,33 +30855,33 @@ fn aiur_fn_325(
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_325] = [__v_0];
-                if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_326] = [__v_0];
+                if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
                 match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_325] = [__v_1];
-                    if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_326] = [__v_1];
+                    if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
                     match __v_10.as_canonical_u64() {
                       1u64 => {
-                        let __ret: [G; OUT_325] = [__v_0];
-                        if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_326] = [__v_0];
+                        if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
                         let __v_11: G = __r_arr[0];
-                        let __ret: [G; OUT_325] = [__v_11];
-                        if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_326] = [__v_11];
+                        if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       _ => {
@@ -30886,15 +30905,15 @@ 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_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_326], 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];
@@ -30902,8 +30921,8 @@ fn aiur_fn_326(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_326] = [__v_3];
-        if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_327] = [__v_3];
+        if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -30920,14 +30939,14 @@ fn aiur_fn_326(
             match __v_6.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(1);
-                let __ret: [G; OUT_326] = [__v_9];
-                if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_327] = [__v_9];
+                if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_326] = [__v_9];
-                if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_327] = [__v_9];
+                if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -30939,16 +30958,16 @@ fn aiur_fn_326(
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_326] = [__v_9];
-                if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_327] = [__v_9];
+                if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_326] = [__v_9];
-                if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_327] = [__v_9];
+                if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -30960,19 +30979,19 @@ fn aiur_fn_326(
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
                 let __v_11: G = (__v_9 * __v_10);
-                let __ret: [G; OUT_326] = [__v_11];
-                if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_327] = [__v_11];
+                if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_326] = [__v_9];
-                if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_327] = [__v_9];
+                if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -30984,19 +31003,19 @@ fn aiur_fn_326(
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               3u64 => {
-                let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
                 let __v_11: G = (__v_9 * __v_10);
-                let __ret: [G; OUT_326] = [__v_11];
-                if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_327] = [__v_11];
+                if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_326] = [__v_9];
-                if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_327] = [__v_9];
+                if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -31012,22 +31031,22 @@ fn aiur_fn_326(
                 match __v_9.as_canonical_u64() {
                   0u64 => {
                     let __v_10: G = G::from_u64(1);
-                    let __ret: [G; OUT_326] = [__v_10];
-                    if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_327] = [__v_10];
+                    if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_10: G = G::from_u64(0);
-                    let __ret: [G; OUT_326] = [__v_10];
-                    if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_327] = [__v_10];
+                    if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_326] = [__v_9];
-                if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_327] = [__v_9];
+                if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -31041,15 +31060,15 @@ fn aiur_fn_326(
   })
 }
 
-const INPUT_SIZE_327: usize = 2;
-const IN_327: usize = 2;
-const OUT_327: usize = 1;
-fn aiur_fn_327(
-  inp: [G; IN_327],
+const INPUT_SIZE_328: usize = 2;
+const IN_328: usize = 2;
+const OUT_328: usize = 1;
+fn aiur_fn_328(
+  inp: [G; IN_328],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_327], 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];
@@ -31059,20 +31078,20 @@ fn aiur_fn_327(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_327] = [__v_6];
-            if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_328] = [__v_6];
+            if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_327] = [__v_6];
-            if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_328] = [__v_6];
+            if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -31082,48 +31101,48 @@ fn aiur_fn_327(
       },
       _ => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_327] = [__v_5];
-        if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_328] = [__v_5];
+        if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_328: usize = 2;
-const IN_328: usize = 2;
-const OUT_328: usize = 1;
-fn aiur_fn_328(
-  inp: [G; IN_328],
+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_328], ExecError> {
+) -> Result<[G; OUT_329], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = G::from_u64(0);
-    let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
-    let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     match __v_8.as_canonical_u64() {
       1u64 => {
         let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_328] = [__v_1];
-            if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_329] = [__v_1];
+            if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
-            let __ret: [G; OUT_328] = [__v_0];
-            if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_329] = [__v_0];
+            if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -31134,8 +31153,8 @@ fn aiur_fn_328(
       0u64 => {
         let __v_9: G = G::from_u64(2);
         let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_328] = [__v_10];
-        if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_329] = [__v_10];
+        if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -31145,15 +31164,15 @@ fn aiur_fn_328(
   })
 }
 
-const INPUT_SIZE_329: usize = 1;
-const IN_329: usize = 1;
-const OUT_329: usize = 2;
-fn aiur_fn_329(
-  inp: [G; IN_329],
+const INPUT_SIZE_330: usize = 1;
+const IN_330: usize = 1;
+const OUT_330: usize = 2;
+fn aiur_fn_330(
+  inp: [G; IN_330],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_329], ExecError> {
+) -> Result<[G; OUT_330], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -31164,12 +31183,12 @@ fn aiur_fn_329(
       0u64 => {
         let __v_4: G = G::from_u64(1);
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_329] = [__v_4, __v_5];
-        if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_330] = [__v_4, __v_5];
+        if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
         match __v_4.as_canonical_u64() {
@@ -31177,15 +31196,15 @@ fn aiur_fn_329(
             let __v_6: G = G::from_u64(1);
             let __v_7: G = G::from_u64(1);
             let __v_8: G = (__v_5 + __v_7);
-            let __ret: [G; OUT_329] = [__v_6, __v_8];
-            if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_330] = [__v_6, __v_8];
+            if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_6: G = G::from_u64(0);
             let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_329] = [__v_6, __v_7];
-            if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_330] = [__v_6, __v_7];
+            if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -31193,23 +31212,23 @@ fn aiur_fn_329(
       _ => {
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_329] = [__v_4, __v_5];
-        if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_330] = [__v_4, __v_5];
+        if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_330: usize = 2;
-const IN_330: usize = 2;
-const OUT_330: usize = 2;
-fn aiur_fn_330(
-  inp: [G; IN_330],
+const INPUT_SIZE_331: usize = 2;
+const IN_331: usize = 2;
+const OUT_331: usize = 2;
+fn aiur_fn_331(
+  inp: [G; IN_331],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_330], 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];
@@ -31221,31 +31240,31 @@ fn aiur_fn_330(
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_1 + __v_5);
-        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __ret: [G; OUT_330] = [__v_7, __v_8];
-        if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_331] = [__v_7, __v_8];
+        if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_330] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_331] = [__v_0, __v_1];
+        if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_331: usize = 2;
-const IN_331: usize = 2;
-const OUT_331: usize = 1;
-fn aiur_fn_331(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_331], 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];
@@ -31258,26 +31277,26 @@ fn aiur_fn_331(
         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_331] = [__v_7];
-        if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_332] = [__v_7];
+        if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_331] = [__v_5];
-        if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_332] = [__v_5];
+        if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_331] = [__v_6];
-            if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_332] = [__v_6];
+            if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
@@ -31287,24 +31306,24 @@ fn aiur_fn_331(
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_331] = [__v_1];
-                if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_332] = [__v_1];
+                if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
                 match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_331] = [__v_0];
-                    if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_332] = [__v_0];
+                    if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   0u64 => {
                     let __v_10: G = G::from_u64(3);
                     let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_331] = [__v_11];
-                    if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_332] = [__v_11];
+                    if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -31323,15 +31342,15 @@ fn aiur_fn_331(
   })
 }
 
-const INPUT_SIZE_332: usize = 1;
-const IN_332: usize = 1;
-const OUT_332: usize = 1;
-fn aiur_fn_332(
-  inp: [G; IN_332],
+const INPUT_SIZE_333: usize = 1;
+const IN_333: usize = 1;
+const OUT_333: usize = 1;
+fn aiur_fn_333(
+  inp: [G; IN_333],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_332], ExecError> {
+) -> Result<[G; OUT_333], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -31343,123 +31362,52 @@ fn aiur_fn_332(
         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_332] = [__v_6];
-        if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_333] = [__v_6];
+        if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
         let __v_4: G = G::from_u64(4);
         let __v_5: G = G::from_u64(0);
         let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_332] = [__v_6];
-        if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_333] = [__v_6];
+        if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = G::from_u64(0);
         let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_332] = [__v_7];
-        if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_332] = [__v_6];
-        if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_332] = [__v_6];
-        if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_333: usize = 2;
-const IN_333: usize = 2;
-const OUT_333: usize = 1;
-fn aiur_fn_333(
-  inp: [G; IN_333],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_333], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = G::from_u64(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_333] = [__v_7];
         if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
-      1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
-        let __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_333] = [__v_8];
-        if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
       2u64 => {
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_333] = [__v_7];
+        let __ret: [G; OUT_333] = [__v_6];
         if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_333] = [__v_7];
-        if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_333] = [__v_5];
+        let __ret: [G; OUT_333] = [__v_6];
         if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
@@ -31482,25 +31430,53 @@ fn aiur_fn_334(
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
+      0u64 => {
+        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_334] = [__v_7];
         if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
+      1u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-        let __v_7: 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_334] = [__v_8];
         if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
+      2u64 => {
+        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_334] = [__v_7];
+        if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_334] = [__v_7];
+        if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __ret: [G; OUT_334] = [__v_5];
+        if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
       _ => {
         return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
@@ -31520,23 +31496,33 @@ fn aiur_fn_335(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_335] = [__v_0];
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_335] = [__v_7];
         if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
-      _ => {
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_335] = [__v_5];
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_335] = [__v_8];
         if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
     }
   })
 }
@@ -31550,6 +31536,39 @@ fn aiur_fn_336(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_336], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_336] = [__v_0];
+        if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __ret: [G; OUT_336] = [__v_5];
+        if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_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_337], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -31563,94 +31582,94 @@ fn aiur_fn_336(
         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_336] = [__v_8];
-        if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_337] = [__v_8];
+        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_336] = [__v_9];
-        if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_337] = [__v_9];
+        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
         let __v_6: G = G::from_u64(2);
-        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_336] = [__v_9];
-        if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_337] = [__v_9];
+        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
         let __v_6: G = G::from_u64(3);
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(0);
         let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_336] = [__v_10];
-        if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_337] = [__v_10];
+        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
         let __v_6: G = G::from_u64(4);
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(0);
         let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_336] = [__v_10];
-        if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_337] = [__v_10];
+        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       5u64 => {
         let __v_6: G = G::from_u64(5);
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(0);
         let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_336] = [__v_10];
-        if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_337] = [__v_10];
+        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       6u64 => {
         let __v_6: G = G::from_u64(6);
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_336] = [__v_10];
-        if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_337] = [__v_10];
+        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       7u64 => {
         let __v_6: G = G::from_u64(7);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_336] = [__v_8];
-        if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_337] = [__v_8];
+        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       8u64 => {
         let __v_6: G = G::from_u64(8);
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_336] = [__v_8];
-        if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_337] = [__v_8];
+        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -31660,15 +31679,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_338: usize = 2;
+const IN_338: usize = 2;
+const OUT_338: usize = 1;
+fn aiur_fn_338(
+  inp: [G; IN_338],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_337], 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];
@@ -31699,14 +31718,14 @@ fn aiur_fn_337(
         match __v_12.as_canonical_u64() {
           1u64 => {
             let __v_22: G = G::from_u64(1);
-            let __ret: [G; OUT_337] = [__v_22];
-            if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_338] = [__v_22];
+            if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_337] = [__v_22];
-            if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_338] = [__v_22];
+            if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -31726,25 +31745,25 @@ fn aiur_fn_337(
         match __v_12.as_canonical_u64() {
           1u64 => {
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_337] = [__v_22];
-            if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_338] = [__v_22];
+            if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_12(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { 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_22: G = __r_arr[0];
             match __v_22.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_337] = [__v_23];
-                if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_338] = [__v_23];
+                if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_337] = [__v_23];
-                if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_338] = [__v_23];
+                if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -31764,15 +31783,15 @@ fn aiur_fn_337(
   })
 }
 
-const INPUT_SIZE_338: usize = 2;
-const IN_338: usize = 2;
-const OUT_338: usize = 1;
-fn aiur_fn_338(
-  inp: [G; IN_338],
+const INPUT_SIZE_339: usize = 2;
+const IN_339: usize = 2;
+const OUT_339: usize = 1;
+fn aiur_fn_339(
+  inp: [G; IN_339],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_338], 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];
@@ -31789,14 +31808,14 @@ fn aiur_fn_338(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_338] = [__v_8];
-            if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_339] = [__v_8];
+            if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_338] = [__v_8];
-            if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_339] = [__v_8];
+            if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -31809,24 +31828,24 @@ fn aiur_fn_338(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_338] = [__v_8];
-            if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_339] = [__v_8];
+            if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = (__v_3 - __v_6);
             match __v_8.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_338] = [__v_9];
-                if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_339] = [__v_9];
+                if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_338] = [__v_9];
-                if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_339] = [__v_9];
+                if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -31843,15 +31862,15 @@ fn aiur_fn_338(
   })
 }
 
-const INPUT_SIZE_339: usize = 4;
-const IN_339: usize = 4;
-const OUT_339: usize = 1;
-fn aiur_fn_339(
-  inp: [G; IN_339],
+const INPUT_SIZE_340: usize = 4;
+const IN_340: usize = 4;
+const OUT_340: usize = 1;
+fn aiur_fn_340(
+  inp: [G; IN_340],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_339], 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];
@@ -31861,16 +31880,16 @@ fn aiur_fn_339(
       0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
             let __v_4: G = __r_arr[0];
-            let __ret: [G; OUT_339] = [__v_4];
-            if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_340] = [__v_4];
+            if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_339] = [__v_4];
-            if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_340] = [__v_4];
+            if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -31878,16 +31897,16 @@ fn aiur_fn_339(
       1u64 => {
         match __v_2.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
             let __v_4: G = __r_arr[0];
-            let __ret: [G; OUT_339] = [__v_4];
-            if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_340] = [__v_4];
+            if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_339] = [__v_4];
-            if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_340] = [__v_4];
+            if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -31899,15 +31918,15 @@ fn aiur_fn_339(
   })
 }
 
-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_341: usize = 1;
+const IN_341: usize = 1;
+const OUT_341: usize = 1;
+fn aiur_fn_341(
+  inp: [G; IN_341],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_340], ExecError> {
+) -> Result<[G; OUT_341], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -31919,77 +31938,77 @@ fn aiur_fn_340(
       0u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_2 + __v_5);
-        let __ret: [G; OUT_340] = [__v_6];
-        if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_341] = [__v_6];
+        if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_340] = [__v_5];
-        if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_341] = [__v_5];
+        if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_340] = [__v_5];
-        if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_341] = [__v_5];
+        if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       7u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_340] = [__v_5];
-        if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_341] = [__v_5];
+        if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_340] = [__v_7];
-        if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_341] = [__v_7];
+        if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_340] = [__v_8];
-        if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_341] = [__v_8];
+        if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_340] = [__v_8];
-        if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_341] = [__v_8];
+        if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_340] = [__v_5];
-        if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_341] = [__v_5];
+        if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_340] = [__v_5];
-        if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_341] = [__v_5];
+        if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -31999,59 +32018,59 @@ fn aiur_fn_340(
   })
 }
 
-const INPUT_SIZE_341: usize = 3;
-const IN_341: usize = 3;
-const OUT_341: usize = 1;
-fn aiur_fn_341(
-  inp: [G; IN_341],
+const INPUT_SIZE_342: usize = 3;
+const IN_342: usize = 3;
+const OUT_342: usize = 1;
+fn aiur_fn_342(
+  inp: [G; IN_342],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_341], ExecError> {
+) -> Result<[G; OUT_342], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_341] = [__v_8];
-    if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_342] = [__v_8];
+    if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_342: usize = 2;
-const IN_342: usize = 2;
-const OUT_342: usize = 1;
-fn aiur_fn_342(
-  inp: [G; IN_342],
+const INPUT_SIZE_343: usize = 2;
+const IN_343: usize = 2;
+const OUT_343: usize = 1;
+fn aiur_fn_343(
+  inp: [G; IN_343],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_342], ExecError> {
+) -> Result<[G; OUT_343], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_342] = [__v_1];
-        if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_343] = [__v_1];
+        if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_342] = [__v_0];
-        if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_343] = [__v_0];
+        if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -32061,57 +32080,57 @@ fn aiur_fn_342(
   })
 }
 
-const INPUT_SIZE_343: usize = 1;
-const IN_343: usize = 1;
-const OUT_343: usize = 1;
-fn aiur_fn_343(
-  inp: [G; IN_343],
+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_343], ExecError> {
+) -> Result<[G; OUT_344], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_1: G = G::from_u64(0);
-        let __ret: [G; OUT_343] = [__v_1];
-        if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_344] = [__v_1];
+        if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_1: G = G::from_u64(1);
         let __v_2: G = (__v_0 - __v_1);
-        let __ret: [G; OUT_343] = [__v_2];
-        if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_344] = [__v_2];
+        if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_344: usize = 2;
-const IN_344: usize = 2;
-const OUT_344: usize = 1;
-fn aiur_fn_344(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_344], ExecError> {
+) -> Result<[G; OUT_345], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_344] = [__v_0];
-        if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_345] = [__v_0];
+        if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_344] = [__v_1];
-        if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_345] = [__v_1];
+        if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -32121,25 +32140,6 @@ 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],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_345], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-    let __ret: [G; OUT_345] = [__v_2];
-    if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
 const INPUT_SIZE_346: usize = 3;
 const IN_346: usize = 3;
 const OUT_346: usize = 1;
@@ -32366,7 +32366,7 @@ fn aiur_fn_349(
     let __v_1: G = inp[1];
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
@@ -32433,7 +32433,7 @@ fn aiur_fn_351(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_352(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } } else { aiur_fn_352(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
@@ -32532,7 +32532,7 @@ fn aiur_fn_353(
           1u64 => {
             let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
             let __v_4: G = __r_arr[0];
-            let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
             let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
@@ -32563,11 +32563,11 @@ fn aiur_fn_354(
   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_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(1);
     let __v_4: G = (__v_1 + __v_3);
-    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       1u64 => {
@@ -32606,7 +32606,7 @@ fn aiur_fn_355(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
@@ -32649,7 +32649,7 @@ fn aiur_fn_355(
         let __v_6: G = __r_arr[0];
         let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __ret: [G; OUT_355] = [__v_8];
         if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -32709,7 +32709,7 @@ fn aiur_fn_356(
     let __v_5: G = (__v_2 + __v_4);
     let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __ret: [G; OUT_356] = [__v_7];
     if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -32735,13 +32735,13 @@ fn aiur_fn_357(
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __v_7: G = G::from_u64(1);
     let __v_8: G = (__v_3 + __v_7);
     let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __ret: [G; OUT_357] = [__v_10];
     if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -32769,9 +32769,9 @@ fn aiur_fn_358(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           0u64 => {
@@ -32998,9 +32998,9 @@ fn aiur_fn_362(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           0u64 => {
@@ -33348,9 +33348,9 @@ fn aiur_fn_367(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       0u64 => {
@@ -33514,7 +33514,7 @@ fn aiur_fn_369(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
@@ -33608,9 +33608,9 @@ fn aiur_fn_371(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           0u64 => {
@@ -33665,7 +33665,7 @@ fn aiur_fn_372(
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = (__v_0 - __v_2);
-    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       1u64 => {
@@ -33917,7 +33917,7 @@ fn aiur_fn_376(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __ret: [G; OUT_376] = [__v_10];
         if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -33970,7 +33970,7 @@ fn aiur_fn_377(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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 __v_8: G = __r_arr[1];
         let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
@@ -34013,7 +34013,7 @@ fn aiur_fn_377(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __ret: [G; OUT_377] = [__v_7];
         if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -34040,9 +34040,9 @@ fn aiur_fn_378(
     let __v_4: G = inp[4];
     let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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 __v_8: G = __r_arr[1];
     let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } };
@@ -34093,7 +34093,7 @@ fn aiur_fn_378(
               _ => {
                 let __v_28: G = G::from_u64(8);
                 let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                 let __v_30: G = __r_arr[0];
                 let __ret: [G; OUT_378] = [__v_30];
                 if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -34104,7 +34104,7 @@ fn aiur_fn_378(
           _ => {
             let __v_15: G = G::from_u64(8);
             let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __ret: [G; OUT_378] = [__v_17];
             if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -34426,7 +34426,7 @@ fn aiur_fn_385(
     let __v_3: G = inp[3];
     let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       0u64 => {
@@ -34451,7 +34451,7 @@ fn aiur_fn_385(
               2u64 => {
                 let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   0u64 => {
@@ -34560,7 +34560,7 @@ fn aiur_fn_385(
                                     let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
                                     let __v_76: G = __r_arr[0];
                                     let __v_77: G = G::from_u64(1);
-                                    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                                     let __v_78: G = __r_arr[0];
                                     let __ret: [G; OUT_385] = [__v_77, __v_78];
                                     if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -34652,7 +34652,7 @@ fn aiur_fn_386(
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __ret: [G; OUT_386] = [__v_5];
         if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -34738,13 +34738,13 @@ fn aiur_fn_388(
     let __v_3: G = __r_arr[0];
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     match __v_8.as_canonical_u64() {
       1u64 => {
@@ -34765,7 +34765,7 @@ fn aiur_fn_388(
             let __v_11: G = G::from_u64(0);
             let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
             match __v_13.as_canonical_u64() {
@@ -34774,11 +34774,11 @@ fn aiur_fn_388(
                 let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
                 let __v_16: G = __r_arr[0];
                 let __v_17: G = G::from_u64(1);
-                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_244] = { let __args: [G; IN_244] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                 let __v_19: G = __r_arr[0];
-                let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_19, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                 let __v_20: G = __r_arr[0];
                 let __ret: [G; OUT_388] = [__v_17, __v_20];
                 if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -34818,7 +34818,7 @@ fn aiur_fn_388(
                 let __v_11: G = G::from_u64(0);
                 let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 match __v_13.as_canonical_u64() {
@@ -34827,13 +34827,13 @@ fn aiur_fn_388(
                     let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
                     let __v_16: G = __r_arr[0];
                     let __v_17: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
                     let __v_18: G = __r_arr[0];
-                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                     let __v_19: G = __r_arr[0];
-                    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
                     let __v_20: G = __r_arr[0];
-                    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_20, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                     let __v_21: G = __r_arr[0];
                     let __ret: [G; OUT_388] = [__v_17, __v_21];
                     if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -34854,7 +34854,7 @@ fn aiur_fn_388(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_388] = [__v_9, __v_10];
@@ -34903,12 +34903,12 @@ fn aiur_fn_389(
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
@@ -34943,9 +34943,9 @@ fn aiur_fn_390(
 ) -> Result<[G; OUT_390], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
   1u64 => {
@@ -34953,9 +34953,9 @@ fn aiur_fn_390(
     break '__mc_0 [__v_3];
   },
   _ => {
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
@@ -34963,9 +34963,9 @@ fn aiur_fn_390(
         break '__mc_0 [__v_5];
       },
       _ => {
-        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
@@ -34973,9 +34973,9 @@ fn aiur_fn_390(
             break '__mc_0 [__v_7];
           },
           _ => {
-            let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
@@ -34983,9 +34983,9 @@ fn aiur_fn_390(
                 break '__mc_0 [__v_9];
               },
               _ => {
-                let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
                 match __v_10.as_canonical_u64() {
                   1u64 => {
@@ -34993,9 +34993,9 @@ fn aiur_fn_390(
                     break '__mc_0 [__v_11];
                   },
                   _ => {
-                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
                     let __v_11: G = __r_arr[0];
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
                     match __v_12.as_canonical_u64() {
                       1u64 => {
@@ -35003,9 +35003,9 @@ fn aiur_fn_390(
                         break '__mc_0 [__v_13];
                       },
                       _ => {
-                        let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
                         let __v_13: G = __r_arr[0];
-                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                         let __v_14: G = __r_arr[0];
                         match __v_14.as_canonical_u64() {
                           1u64 => {
@@ -35013,9 +35013,9 @@ fn aiur_fn_390(
                             break '__mc_0 [__v_15];
                           },
                           _ => {
-                            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
                             let __v_15: G = __r_arr[0];
-                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                             let __v_16: G = __r_arr[0];
                             match __v_16.as_canonical_u64() {
                               1u64 => {
@@ -35023,9 +35023,9 @@ fn aiur_fn_390(
                                 break '__mc_0 [__v_17];
                               },
                               _ => {
-                                let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
                                 let __v_17: G = __r_arr[0];
-                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                 let __v_18: G = __r_arr[0];
                                 match __v_18.as_canonical_u64() {
                                   1u64 => {
@@ -35033,9 +35033,9 @@ fn aiur_fn_390(
                                     break '__mc_0 [__v_19];
                                   },
                                   _ => {
-                                    let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
                                     let __v_19: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                     let __v_20: G = __r_arr[0];
                                     match __v_20.as_canonical_u64() {
                                       1u64 => {
@@ -35043,9 +35043,9 @@ fn aiur_fn_390(
                                         break '__mc_0 [__v_21];
                                       },
                                       _ => {
-                                        let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
                                         let __v_21: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                         let __v_22: G = __r_arr[0];
                                         match __v_22.as_canonical_u64() {
                                           1u64 => {
@@ -35053,9 +35053,9 @@ fn aiur_fn_390(
                                             break '__mc_0 [__v_23];
                                           },
                                           _ => {
-                                            let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
                                             let __v_23: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                             let __v_24: G = __r_arr[0];
                                             match __v_24.as_canonical_u64() {
                                               1u64 => {
@@ -35063,9 +35063,9 @@ fn aiur_fn_390(
                                                 break '__mc_0 [__v_25];
                                               },
                                               _ => {
-                                                let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
                                                 let __v_25: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                 let __v_26: G = __r_arr[0];
                                                 match __v_26.as_canonical_u64() {
                                                   1u64 => {
@@ -35073,9 +35073,9 @@ fn aiur_fn_390(
                                                     break '__mc_0 [__v_27];
                                                   },
                                                   _ => {
-                                                    let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
                                                     let __v_27: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                     let __v_28: G = __r_arr[0];
                                                     match __v_28.as_canonical_u64() {
                                                       1u64 => {
@@ -35083,9 +35083,9 @@ fn aiur_fn_390(
                                                         break '__mc_0 [__v_29];
                                                       },
                                                       _ => {
-                                                        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
                                                         let __v_29: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                         let __v_30: G = __r_arr[0];
                                                         match __v_30.as_canonical_u64() {
                                                           1u64 => {
@@ -35093,9 +35093,9 @@ fn aiur_fn_390(
                                                             break '__mc_0 [__v_31];
                                                           },
                                                           _ => {
-                                                            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+                                                            let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
                                                             let __v_31: G = __r_arr[0];
-                                                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                             let __v_32: G = __r_arr[0];
                                                             match __v_32.as_canonical_u64() {
                                                               1u64 => {
@@ -35147,7 +35147,7 @@ fn aiur_fn_390(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
@@ -35157,7 +35157,7 @@ fn aiur_fn_390(
             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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
             match __v_5.as_canonical_u64() {
               1u64 => {
@@ -35167,7 +35167,7 @@ fn aiur_fn_390(
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
                 let __v_6: G = __r_arr[0];
                 match __v_6.as_canonical_u64() {
                   1u64 => {
@@ -35187,7 +35187,7 @@ fn aiur_fn_390(
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { 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_242] = { let __args: [G; IN_242] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
                         let __v_8: G = __r_arr[0];
                         match __v_8.as_canonical_u64() {
                           1u64 => {
@@ -35244,7 +35244,7 @@ fn aiur_fn_391(
       2u64 => {
         let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __ret: [G; OUT_391] = [__v_6, __v_7];
@@ -35252,7 +35252,7 @@ fn aiur_fn_391(
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
         let __ret: [G; OUT_391] = [__v_5, __v_6];
@@ -35260,7 +35260,7 @@ fn aiur_fn_391(
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
         let __ret: [G; OUT_391] = [__v_5, __v_6];
@@ -35276,7 +35276,7 @@ fn aiur_fn_391(
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
         let __ret: [G; OUT_391] = [__v_5, __v_6];
@@ -35312,7 +35312,7 @@ fn aiur_fn_392(
     let __v_2: G = inp[2];
     let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
@@ -35326,7 +35326,7 @@ fn aiur_fn_392(
       _ => {
         let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
@@ -35399,7 +35399,7 @@ fn aiur_fn_393(
             let __v_14: G = G::from_u64(3);
             let __v_15: G = G::from_u64(0);
             let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __ret: [G; OUT_393] = [__v_13, __v_17];
             if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -35467,7 +35467,7 @@ fn aiur_fn_394(
             let __v_14: G = G::from_u64(3);
             let __v_15: G = G::from_u64(0);
             let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __ret: [G; OUT_394] = [__v_13, __v_17];
             if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -35503,7 +35503,7 @@ fn aiur_fn_395(
     let __v_1: G = inp[1];
     let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: 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_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -35515,7 +35515,7 @@ fn aiur_fn_395(
       2u64 => {
         let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         match __v_10.as_canonical_u64() {
           1u64 => {
@@ -35603,7 +35603,7 @@ fn aiur_fn_396(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -35632,7 +35632,7 @@ fn aiur_fn_396(
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
                 let __v_22: G = __r_arr[0];
                 let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
@@ -35643,7 +35643,7 @@ fn aiur_fn_396(
             }
           },
           2u64 => {
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
             let __ret: [G; OUT_396] = [__v_20];
             if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -35662,7 +35662,7 @@ fn aiur_fn_396(
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                 let __v_22: G = __r_arr[0];
                 let __ret: [G; OUT_396] = [__v_22];
                 if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -35741,7 +35741,7 @@ fn aiur_fn_396(
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                     let __v_28: G = __r_arr[0];
                     let __ret: [G; OUT_396] = [__v_28];
                     if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -35752,7 +35752,7 @@ fn aiur_fn_396(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
             let __ret: [G; OUT_396] = [__v_20];
             if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -35807,7 +35807,7 @@ fn aiur_fn_397(
             let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = G::from_u64(1);
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
             let __ret: [G; OUT_397] = [__v_14, __v_15];
             if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -36033,12 +36033,12 @@ fn aiur_fn_399(
       7u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
             match __v_5.as_canonical_u64() {
               1u64 => {
                 let __v_6: G = G::from_u64(2);
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
                 let __v_8: G = G::from_u64(1);
                 let __v_9: G = G::from_u64(1);
@@ -36050,16 +36050,16 @@ fn aiur_fn_399(
                 return Ok(__ret);
               },
               _ => {
-                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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
                 let __v_6: G = __r_arr[0];
-                let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
                 let __v_8: G = G::from_u64(7);
                 let __v_9: G = G::from_u64(0);
                 let __v_10: G = G::from_u64(0);
                 let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_12: G = G::from_u64(2);
-                let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = G::from_u64(1);
                 let __v_15: G = G::from_u64(1);
@@ -36125,7 +36125,7 @@ fn aiur_fn_400(
             let __v_16: G = (__v_2 + __v_15);
             let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
             let __v_18: G = __r_arr[0];
             match __v_18.as_canonical_u64() {
               0u64 => {
@@ -36155,7 +36155,7 @@ fn aiur_fn_400(
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_12, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
                     let __v_21: G = __r_arr[0];
                     let __v_22: G = (__v_3 + __v_4);
                     let __v_23: G = (__v_2 + __v_22);
@@ -36165,9 +36165,9 @@ fn aiur_fn_400(
                     let __v_26: G = (__v_16 + __v_25);
                     let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
                     let __v_27: G = __r_arr[0];
-                    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                     let __v_28: G = __r_arr[0];
-                    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                     let __v_29: G = __r_arr[0];
                     let __v_30: G = G::from_u64(1);
                     let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_29, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
@@ -36215,7 +36215,7 @@ fn aiur_fn_401(
     let __v_5: G = __r_arr[0];
     let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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 __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 };
@@ -36225,7 +36225,7 @@ fn aiur_fn_401(
     let __v_12: G = __loaded[3];
     match __v_9.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         match __v_13.as_canonical_u64() {
           0u64 => {
@@ -36235,7 +36235,7 @@ fn aiur_fn_401(
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
             let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_15: G = __loaded[0];
@@ -36259,7 +36259,7 @@ fn aiur_fn_401(
                 let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
                 let __v_31: G = __r_arr[0];
-                let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                 let __v_32: G = __r_arr[0];
                 let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } };
                 let __v_33: G = __r_arr[0];
@@ -36337,7 +36337,7 @@ fn aiur_fn_403(
     let __v_1: G = inp[1];
     let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: 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_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -36347,7 +36347,7 @@ fn aiur_fn_403(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
@@ -36364,7 +36364,7 @@ fn aiur_fn_403(
         let __v_21: G = __loaded[11];
         match __v_10.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
             let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
@@ -36428,7 +36428,7 @@ fn aiur_fn_404(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_262(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } } else { aiur_fn_262(__args, record, io_buffer, __cu)? } };
         let __v_15: G = __r_arr[0];
         let __v_16: G = __r_arr[1];
         match __v_15.as_canonical_u64() {
@@ -36441,11 +36441,11 @@ fn aiur_fn_404(
           _ => {
             let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } };
             let __v_18: G = __r_arr[0];
             let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } };
             let __v_19: G = __r_arr[0];
-            let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
             let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
@@ -36460,7 +36460,7 @@ fn aiur_fn_404(
                 let __v_26: G = __r_arr[0];
                 let __v_27: G = __r_arr[1];
                 let __v_28: G = __r_arr[2];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_29: G = __r_arr[0];
                 let __v_30: G = G::from_u64(1);
                 if (__v_29 != __v_30) {
@@ -36471,14 +36471,14 @@ fn aiur_fn_404(
                     let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_402(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } } else { aiur_fn_402(__args, record, io_buffer, __cu)? } };
                     let __v_31: G = __r_arr[0];
                     let __v_32: G = G::from_u64(2);
-                    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                     let __v_33: G = __r_arr[0];
                     let __ret: [G; OUT_404] = [__v_32, __v_33];
                     if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
                     let __v_31: G = __r_arr[0];
                     let __v_32: G = (__v_3 + __v_4);
                     let __v_33: G = (__v_2 + __v_32);
@@ -36493,11 +36493,11 @@ fn aiur_fn_404(
                     let __v_39: G = (__v_12 + __v_38);
                     let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
                     let __v_40: G = __r_arr[0];
-                    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                     let __v_41: G = __r_arr[0];
-                    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_41, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_41, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                     let __v_42: G = __r_arr[0];
-                    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                     let __v_43: G = __r_arr[0];
                     let __v_44: G = G::from_u64(1);
                     let __ret: [G; OUT_404] = [__v_44, __v_43];
@@ -36513,7 +36513,7 @@ fn aiur_fn_404(
                 let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_402(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } } else { aiur_fn_402(__args, record, io_buffer, __cu)? } };
                 let __v_26: G = __r_arr[0];
                 let __v_27: G = G::from_u64(2);
-                let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                 let __v_28: G = __r_arr[0];
                 let __ret: [G; OUT_404] = [__v_27, __v_28];
                 if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -36538,7 +36538,7 @@ fn aiur_fn_405(
 ) -> Result<[G; OUT_405], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: 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_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -36548,7 +36548,7 @@ fn aiur_fn_405(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -36800,7 +36800,7 @@ fn aiur_fn_407(
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
                     let __v_24: G = __r_arr[0];
                     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                     let __v_25: G = __loaded[0];
@@ -36841,9 +36841,9 @@ fn aiur_fn_407(
                                     let __v_40: G = __r_arr[0];
                                     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
                                     let __v_41: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
                                     let __v_42: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
                                     let __v_43: G = __r_arr[0];
                                     match __v_43.as_canonical_u64() {
                                       1u64 => {
@@ -36873,13 +36873,13 @@ fn aiur_fn_407(
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
                                             let __v_46: G = __r_arr[0];
                                             let __v_47: G = (__v_3 + __v_4);
                                             let __v_48: G = (__v_47 + __v_5);
                                             let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_2, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
                                             let __v_49: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                                             let __v_50: G = __r_arr[0];
                                             let __v_51: G = G::from_u64(0);
                                             let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } };
@@ -36889,7 +36889,7 @@ fn aiur_fn_407(
                                             let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
                                             let __v_55: G = __r_arr[0];
                                             let __v_56: G = G::from_u64(1);
-                                            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_52, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_52, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                                             let __v_57: G = __r_arr[0];
                                             let __ret: [G; OUT_407] = [__v_56, __v_57];
                                             if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -36974,7 +36974,7 @@ fn aiur_fn_408(
         let __v_5: G = __loaded[3];
         match __v_2.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             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 };
@@ -37184,7 +37184,7 @@ fn aiur_fn_410(
 ) -> Result<[G; OUT_410], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
@@ -37232,7 +37232,7 @@ fn aiur_fn_411(
   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_281] = { let __args: [G; IN_281] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -37285,7 +37285,7 @@ fn aiur_fn_411(
       _ => {
         match __v_2.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
             let __v_50: G = __r_arr[0];
             let __ret: [G; OUT_411] = [__v_50];
             if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -37332,7 +37332,7 @@ fn aiur_fn_412(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -37629,7 +37629,7 @@ fn aiur_fn_416(
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
@@ -37698,7 +37698,7 @@ fn aiur_fn_417(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
@@ -37785,7 +37785,7 @@ fn aiur_fn_419(
         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_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
@@ -37819,7 +37819,7 @@ fn aiur_fn_420(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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 __v_8: G = __r_arr[1];
         let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
@@ -37842,7 +37842,7 @@ fn aiur_fn_420(
         let __v_13: G = __r_arr[0];
         match __v_13.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
             let __ret: [G; OUT_420] = [__v_14];
             if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -37898,7 +37898,7 @@ fn aiur_fn_420(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __ret: [G; OUT_420] = [__v_7];
         if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -37926,7 +37926,7 @@ fn aiur_fn_421(
     let __v_5: G = inp[5];
     let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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 __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 };
@@ -37963,7 +37963,7 @@ fn aiur_fn_421(
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_26: G = __r_arr[0];
             let __ret: [G; OUT_421] = [__v_26];
             if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -37972,7 +37972,7 @@ fn aiur_fn_421(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __ret: [G; OUT_421] = [__v_13];
         if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -37997,7 +37997,7 @@ fn aiur_fn_422(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_6: G = __loaded[0];
@@ -38028,7 +38028,7 @@ fn aiur_fn_422(
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __ret: [G; OUT_422] = [__v_21];
             if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -38037,7 +38037,7 @@ fn aiur_fn_422(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
         let __ret: [G; OUT_422] = [__v_18];
         if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -38091,7 +38091,7 @@ fn aiur_fn_423(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
@@ -38151,7 +38151,7 @@ fn aiur_fn_425(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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 __v_8: G = __r_arr[1];
         let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
@@ -38194,7 +38194,7 @@ fn aiur_fn_425(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __ret: [G; OUT_425] = [__v_7];
         if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -38228,7 +38228,7 @@ fn aiur_fn_426(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __ret: [G; OUT_426] = [__v_10];
         if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -38278,9 +38278,9 @@ fn aiur_fn_427(
     let __v_4: G = inp[4];
     let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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 __v_8: G = __r_arr[1];
     let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } };
@@ -38331,7 +38331,7 @@ fn aiur_fn_427(
               _ => {
                 let __v_28: G = G::from_u64(8);
                 let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                 let __v_30: G = __r_arr[0];
                 let __ret: [G; OUT_427] = [__v_30];
                 if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -38342,7 +38342,7 @@ fn aiur_fn_427(
           _ => {
             let __v_15: G = G::from_u64(8);
             let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __ret: [G; OUT_427] = [__v_17];
             if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -38373,9 +38373,9 @@ fn aiur_fn_428(
     let __v_5: G = __r_arr[0];
     let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_5.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     match __v_7.as_canonical_u64() {
       0u64 => {
@@ -38418,7 +38418,7 @@ fn aiur_fn_428(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
@@ -38447,7 +38447,7 @@ fn aiur_fn_428(
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
                 let __ret: [G; OUT_428] = [__v_23];
                 if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -38468,7 +38468,7 @@ fn aiur_fn_428(
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
                 let __ret: [G; OUT_428] = [__v_23];
                 if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -38547,7 +38547,7 @@ fn aiur_fn_428(
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                     let __v_29: G = __r_arr[0];
                     let __ret: [G; OUT_428] = [__v_29];
                     if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -38558,7 +38558,7 @@ fn aiur_fn_428(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __ret: [G; OUT_428] = [__v_21];
             if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -38747,7 +38747,7 @@ fn aiur_fn_432(
   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_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
@@ -38774,7 +38774,7 @@ fn aiur_fn_432(
         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_332] = { let __args: [G; IN_332] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         let __v_13: G = G::from_u64(0);
         let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
@@ -38783,7 +38783,7 @@ fn aiur_fn_432(
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
@@ -38807,7 +38807,7 @@ fn aiur_fn_432(
         if (__v_23 != __v_21) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) });
         }
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
         let __ret: [G; OUT_432] = [__v_24];
         if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -38874,7 +38874,7 @@ fn aiur_fn_432(
         let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(1);
-        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
         let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
@@ -38909,7 +38909,7 @@ fn aiur_fn_432(
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = G::from_u64(1);
             let __v_11: G = G::from_u64(1);
@@ -38930,7 +38930,7 @@ fn aiur_fn_432(
         let __v_8: G = __r_arr[0];
         let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_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 };
@@ -38940,7 +38940,7 @@ fn aiur_fn_432(
         let __v_15: G = __loaded[3];
         match __v_12.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
             let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_17: G = __loaded[0];
@@ -38961,7 +38961,7 @@ fn aiur_fn_432(
             match __v_17.as_canonical_u64() {
               5u64 => {
                 let __v_29: G = G::from_u64(0);
-                let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
                 let __v_30: G = __r_arr[0];
                 let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                 let __v_31: G = __loaded[0];
@@ -38982,7 +38982,7 @@ fn aiur_fn_432(
                 }
                 match __v_31.as_canonical_u64() {
                   6u64 => {
-                    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_33, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_33, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
                     let __v_44: G = __r_arr[0];
                     let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
                     let __v_45: G = __r_arr[0];
@@ -39050,7 +39050,7 @@ fn aiur_fn_433(
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(0);
         let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
@@ -39059,7 +39059,7 @@ fn aiur_fn_433(
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
@@ -39083,7 +39083,7 @@ fn aiur_fn_433(
         if (__v_21 != __v_19) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) });
         }
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
         let __ret: [G; OUT_433] = [__v_22];
         if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -39150,7 +39150,7 @@ fn aiur_fn_433(
         let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(1);
-        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
@@ -39185,7 +39185,7 @@ fn aiur_fn_433(
           },
           1u64 => {
             let __v_6: G = G::from_u64(2);
-            let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __v_8: G = G::from_u64(1);
             let __v_9: G = G::from_u64(1);
@@ -39206,7 +39206,7 @@ fn aiur_fn_433(
         let __v_6: G = __r_arr[0];
         let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -39216,7 +39216,7 @@ fn aiur_fn_433(
         let __v_13: G = __loaded[3];
         match __v_10.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
             let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_15: G = __loaded[0];
@@ -39237,7 +39237,7 @@ fn aiur_fn_433(
             match __v_15.as_canonical_u64() {
               5u64 => {
                 let __v_27: G = G::from_u64(0);
-                let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
                 let __v_28: G = __r_arr[0];
                 let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                 let __v_29: G = __loaded[0];
@@ -39258,7 +39258,7 @@ fn aiur_fn_433(
                 }
                 match __v_29.as_canonical_u64() {
                   6u64 => {
-                    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
                     let __v_42: G = __r_arr[0];
                     let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
                     let __v_43: G = __r_arr[0];
@@ -39499,7 +39499,7 @@ fn aiur_fn_437(
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               0u64 => {
@@ -39551,11 +39551,11 @@ fn aiur_fn_438(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           0u64 => {
@@ -39601,11 +39601,11 @@ fn aiur_fn_439(
     let __v_6: G = G::from_u64(0);
     let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     match __v_10.as_canonical_u64() {
       0u64 => {
@@ -39718,10 +39718,10 @@ fn aiur_fn_442(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_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_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -39901,7 +39901,7 @@ fn aiur_fn_444(
       7u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
             let __ret: [G; OUT_444] = [__v_5];
             if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -39916,9 +39916,9 @@ fn aiur_fn_444(
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __ret: [G; OUT_444] = [__v_6];
         if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -39958,7 +39958,7 @@ fn aiur_fn_445(
             let __v_6: G = G::from_u64(1);
             let __v_7: G = G::from_u64(1);
             let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __ret: [G; OUT_445] = [__v_5, __v_9, __v_3];
             if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -39983,9 +39983,9 @@ fn aiur_fn_445(
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
@@ -39994,7 +39994,7 @@ fn aiur_fn_445(
                 let __v_12: G = __r_arr[1];
                 let __v_13: G = __r_arr[2];
                 let __v_14: G = G::from_u64(1);
-                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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 __ret: [G; OUT_445] = [__v_14, __v_12, __v_15];
                 if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -40019,9 +40019,9 @@ fn aiur_fn_445(
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 match __v_14.as_canonical_u64() {
                   1u64 => {
@@ -40041,7 +40041,7 @@ fn aiur_fn_445(
                             match __v_19.as_canonical_u64() {
                               1u64 => {
                                 let __v_22: G = G::from_u64(1);
-                                let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_21, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_21, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
                                 let __v_23: G = __r_arr[0];
                                 let __ret: [G; OUT_445] = [__v_22, __v_20, __v_23];
                                 if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -40168,7 +40168,7 @@ fn aiur_fn_446(
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             match __v_13.as_canonical_u64() {
               0u64 => {
@@ -40249,9 +40249,9 @@ fn aiur_fn_448(
       7u64 => {
         match __v_4.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
@@ -40472,7 +40472,7 @@ fn aiur_fn_452(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __ret: [G; OUT_452] = [__v_11];
             if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -40739,10 +40739,10 @@ fn aiur_fn_455(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
@@ -40776,7 +40776,7 @@ fn aiur_fn_455(
                 let __v_18: G = __loaded[3];
                 match __v_15.as_canonical_u64() {
                   8u64 => {
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_19: G = __r_arr[0];
                     let __v_20: G = (__v_13 - __v_17);
                     let __v_21: G = G::from_bool((__v_20 == G::ZERO));
@@ -41009,7 +41009,7 @@ fn aiur_fn_458(
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __ret: [G; OUT_458] = [__v_13, __v_2];
                 if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -41033,7 +41033,7 @@ fn aiur_fn_458(
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 match __v_13.as_canonical_u64() {
                   1u64 => {
@@ -41189,7 +41189,7 @@ fn aiur_fn_458(
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               7u64 => {
-                let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __ret: [G; OUT_458] = [__v_13, __v_2];
                 if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -41213,7 +41213,7 @@ fn aiur_fn_458(
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               8u64 => {
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 match __v_13.as_canonical_u64() {
                   1u64 => {
@@ -41468,7 +41468,7 @@ fn aiur_fn_461(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: 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_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -41478,7 +41478,7 @@ fn aiur_fn_461(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
@@ -41501,7 +41501,7 @@ fn aiur_fn_461(
             let __v_24: G = (__v_22 - __v_23);
             match __v_24.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
                 let __v_25: G = __r_arr[0];
                 let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                 let __v_26: G = __loaded[0];
@@ -41671,7 +41671,7 @@ fn aiur_fn_463(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -41694,9 +41694,9 @@ fn aiur_fn_463(
     let __v_21: G = G::from_u64(1);
     let __v_22: G = G::from_u64(1);
     let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_25: G = __r_arr[0];
     let __ret: [G; OUT_463] = [__v_25];
     if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -41821,7 +41821,7 @@ fn aiur_fn_466(
 ) -> Result<[G; OUT_466], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: 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_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -41831,7 +41831,7 @@ fn aiur_fn_466(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -41855,7 +41855,7 @@ fn aiur_fn_466(
                 match __v_21.as_canonical_u64() {
                   0u64 => {
                     let __v_22: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
                     let __v_23: G = __r_arr[0];
                     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                     let __v_24: G = __loaded[0];
@@ -42058,7 +42058,7 @@ fn aiur_fn_469(
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
         let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __ret: [G; OUT_469] = [__v_11];
         if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -42154,7 +42154,7 @@ fn aiur_fn_471(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __ret: [G; OUT_471] = [__v_11];
             if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -42176,7 +42176,7 @@ fn aiur_fn_471(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
@@ -42339,7 +42339,7 @@ fn aiur_fn_471(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __ret: [G; OUT_471] = [__v_11];
             if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -42375,7 +42375,7 @@ fn aiur_fn_471(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
@@ -42575,7 +42575,7 @@ fn aiur_fn_474(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_7: G = __loaded[0];
@@ -42590,7 +42590,7 @@ fn aiur_fn_474(
     let __v_16: G = __loaded[9];
     let __v_17: G = __loaded[10];
     let __v_18: G = __loaded[11];
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_20: G = __loaded[0];
@@ -42856,7 +42856,7 @@ fn aiur_fn_478(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -42941,7 +42941,7 @@ fn aiur_fn_479(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -43124,7 +43124,7 @@ fn aiur_fn_482(
   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_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_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 };
@@ -43136,7 +43136,7 @@ fn aiur_fn_482(
       8u64 => {
         let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_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 };
@@ -43154,7 +43154,7 @@ fn aiur_fn_482(
                 let __v_17: G = G::from_u64(8);
                 let __v_18: G = { let __values: [G; 4] = [__v_17, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_19: G = G::from_u64(1);
-                let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
                 let __v_20: G = __r_arr[0];
                 let __ret: [G; OUT_482] = [__v_19, __v_20];
                 if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -43197,7 +43197,7 @@ fn aiur_fn_483(
 ) -> Result<[G; OUT_483], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: 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_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -43207,7 +43207,7 @@ fn aiur_fn_483(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -43224,20 +43224,20 @@ fn aiur_fn_483(
         let __v_19: G = __loaded[11];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
             let __v_21: G = G::from_u64(1);
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
             let __ret: [G; OUT_483] = [__v_21, __v_22];
             if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
             let __v_21: G = G::from_u64(1);
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
             let __ret: [G; OUT_483] = [__v_21, __v_22];
             if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -43296,7 +43296,7 @@ fn aiur_fn_484(
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_8: G = __loaded[0];
@@ -43311,7 +43311,7 @@ fn aiur_fn_484(
             let __v_17: G = __loaded[9];
             let __v_18: G = __loaded[10];
             let __v_19: G = __loaded[11];
-            let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
             let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_21: G = __loaded[0];
@@ -43390,7 +43390,7 @@ fn aiur_fn_485(
 ) -> Result<[G; OUT_485], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: 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_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -43537,7 +43537,7 @@ fn aiur_fn_487(
   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_340] = { let __args: [G; IN_340] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       0u64 => {
@@ -43579,7 +43579,7 @@ fn aiur_fn_488(
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     match __v_6.as_canonical_u64() {
       0u64 => {
@@ -43648,7 +43648,7 @@ fn aiur_fn_489(
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(0);
         let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
@@ -43657,7 +43657,7 @@ fn aiur_fn_489(
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
@@ -43681,14 +43681,14 @@ fn aiur_fn_489(
         if (__v_20 != __v_19) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) });
         }
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
         let __ret: [G; OUT_489] = [__v_22];
         if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } };
@@ -43724,7 +43724,7 @@ fn aiur_fn_489(
         let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(1);
-        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
@@ -43915,7 +43915,7 @@ fn aiur_fn_491(
       },
       1u64 => {
         let __v_2: G = G::from_u64(2);
-        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = G::from_u64(1);
         let __v_5: G = G::from_u64(1);
@@ -43947,7 +43947,7 @@ fn aiur_fn_492(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
@@ -43961,7 +43961,7 @@ fn aiur_fn_492(
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
         let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __ret: [G; OUT_492] = [__v_13];
         if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -44051,7 +44051,7 @@ fn aiur_fn_494(
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
         let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(1);
         if (__v_7 != __v_8) {
@@ -44091,7 +44091,7 @@ fn aiur_fn_495(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
@@ -44100,7 +44100,7 @@ fn aiur_fn_495(
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = G::from_u64(0);
             if (__v_9 != __v_10) {
@@ -44190,7 +44190,7 @@ fn aiur_fn_497(
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     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 };
@@ -44200,7 +44200,7 @@ fn aiur_fn_497(
     let __v_11: G = __loaded[3];
     match __v_8.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_13: G = __loaded[0];
@@ -44221,7 +44221,7 @@ fn aiur_fn_497(
         match __v_13.as_canonical_u64() {
           5u64 => {
             let __v_25: G = G::from_u64(0);
-            let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
             let __v_26: G = __r_arr[0];
             let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_27: G = __loaded[0];
@@ -44242,7 +44242,7 @@ fn aiur_fn_497(
             }
             match __v_27.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
                 let __v_40: G = __r_arr[0];
                 let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
                 let __v_41: G = __r_arr[0];
@@ -45033,7 +45033,7 @@ fn aiur_fn_514(
     let __v_0: G = inp[0];
     let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
@@ -45045,7 +45045,7 @@ fn aiur_fn_514(
       _ => {
         let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
@@ -45057,7 +45057,7 @@ fn aiur_fn_514(
           _ => {
             let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             match __v_6.as_canonical_u64() {
               1u64 => {
@@ -45069,7 +45069,7 @@ fn aiur_fn_514(
               _ => {
                 let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_8: G = __r_arr[0];
                 match __v_8.as_canonical_u64() {
                   1u64 => {
@@ -45081,7 +45081,7 @@ fn aiur_fn_514(
                   _ => {
                     let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } };
                     let __v_9: G = __r_arr[0];
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
                     match __v_10.as_canonical_u64() {
                       1u64 => {
@@ -45093,7 +45093,7 @@ fn aiur_fn_514(
                       _ => {
                         let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } };
                         let __v_11: G = __r_arr[0];
-                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                         let __v_12: G = __r_arr[0];
                         match __v_12.as_canonical_u64() {
                           1u64 => {
@@ -45135,7 +45135,7 @@ fn aiur_fn_515(
     let __v_0: G = inp[0];
     let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
@@ -45147,7 +45147,7 @@ fn aiur_fn_515(
       _ => {
         let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
@@ -45159,7 +45159,7 @@ fn aiur_fn_515(
           _ => {
             let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             match __v_6.as_canonical_u64() {
               1u64 => {
@@ -45207,13 +45207,13 @@ fn aiur_fn_516(
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __v_13: G = (__v_10 + __v_12);
             match __v_13.as_canonical_u64() {
@@ -45308,12 +45308,12 @@ fn aiur_fn_517(
     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_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     break '__mc_0 [__v_2];
   },
   _ => {
-    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     break '__mc_0 [__v_2];
   },
@@ -45469,7 +45469,7 @@ fn aiur_fn_519(
             let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
             let __v_26: G = __r_arr[0];
             let __v_27: G = G::from_u64(1);
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
             let __ret: [G; OUT_519] = [__v_27, __v_28];
             if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -45545,15 +45545,15 @@ fn aiur_fn_520(
           _ => {
             let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             match __v_13.as_canonical_u64() {
               1u64 => {
@@ -45601,7 +45601,7 @@ fn aiur_fn_521(
     let __v_6: G = __r_arr[0];
     let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
     match __v_8.as_canonical_u64() {
@@ -45616,9 +45616,9 @@ fn aiur_fn_521(
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(2);
         let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } };
@@ -45635,7 +45635,7 @@ fn aiur_fn_521(
         let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
         let __v_24: G = G::from_u64(1);
-        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __ret: [G; OUT_521] = [__v_24, __v_25];
         if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -45674,7 +45674,7 @@ fn aiur_fn_522(
     let __v_10: G = __r_arr[0];
     let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
     match __v_12.as_canonical_u64() {
@@ -45689,7 +45689,7 @@ fn aiur_fn_522(
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         match __v_14.as_canonical_u64() {
@@ -45706,12 +45706,12 @@ fn aiur_fn_522(
           1u64 => {
             let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { 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_16: G = __r_arr[0];
     break '__mc_0 [__v_16];
   },
   _ => {
-    let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
     break '__mc_0 [__v_16];
   },
@@ -45797,12 +45797,12 @@ fn aiur_fn_523(
         let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } };
     let __v_34: G = __r_arr[0];
     break '__mc_0 [__v_34];
   },
   _ => {
-    let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
     let __v_34: G = __r_arr[0];
     break '__mc_0 [__v_34];
   },
@@ -45932,7 +45932,7 @@ fn aiur_fn_524(
                   7u64 => {
                     match __v_15.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
                         let __v_18: G = __r_arr[0];
                         match __v_18.as_canonical_u64() {
                           0u64 => {
@@ -46038,7 +46038,7 @@ fn aiur_fn_525(
     let __v_17: G = G::from_u64(0);
     let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_19: G = G::from_u64(2);
-    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
     let __v_20: G = __r_arr[0];
     let __v_21: G = G::from_u64(1);
     let __v_22: G = G::from_u64(1);
@@ -46064,13 +46064,13 @@ fn aiur_fn_525(
     let __v_42: G = G::from_u64(2);
     let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
     let __v_43: G = __r_arr[0];
-    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
     let __v_44: G = __r_arr[0];
     let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } };
     let __v_45: G = __r_arr[0];
     let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
     let __v_46: G = __r_arr[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_47: G = __r_arr[0];
     let __v_48: G = __r_arr[1];
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
@@ -46110,7 +46110,7 @@ fn aiur_fn_525(
         let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
         let __v_68: G = __r_arr[0];
         let __v_69: G = G::from_u64(1);
-        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
         let __v_70: G = __r_arr[0];
         let __ret: [G; OUT_525] = [__v_69, __v_70];
         if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -46156,13 +46156,13 @@ fn aiur_fn_526(
     let __v_10: G = G::from_u64(2);
     let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
     let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
     let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
@@ -46200,7 +46200,7 @@ fn aiur_fn_526(
         let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
         let __v_35: G = __r_arr[0];
         let __v_36: G = G::from_u64(1);
-        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
         let __ret: [G; OUT_526] = [__v_36, __v_37];
         if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -46566,7 +46566,7 @@ fn aiur_fn_536(
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
@@ -46605,7 +46605,7 @@ fn aiur_fn_537(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
@@ -46991,9 +46991,9 @@ fn aiur_fn_541(
   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_121] = { let __args: [G; IN_121] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
@@ -48234,7 +48234,7 @@ fn aiur_fn_552(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
@@ -48249,7 +48249,7 @@ fn aiur_fn_552(
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
         let __v_20: G = __loaded[11];
-        let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_22: G = __loaded[0];
@@ -48409,7 +48409,7 @@ fn aiur_fn_554(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = G::from_u64(4);
-    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     let __v_6: G = __r_arr[2];
@@ -48418,7 +48418,7 @@ fn aiur_fn_554(
     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_292] = { let __args: [G; IN_292] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
     let __v_14: G = __r_arr[2];
@@ -48440,9 +48440,9 @@ fn aiur_fn_554(
     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_72] = { let __args: [G; IN_72] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __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_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __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_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_34: G = __r_arr[0];
     let __ret: [G; OUT_554] = [__v_34];
     if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -48464,7 +48464,7 @@ fn aiur_fn_555(
     let __v_1: G = inp[1];
     let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
@@ -49195,7 +49195,7 @@ fn aiur_fn_569(
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               0u64 => {
@@ -49530,7 +49530,7 @@ fn aiur_fn_574(
 ) -> Result<[G; OUT_574], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -49608,7 +49608,7 @@ fn aiur_fn_574(
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
                 let __v_60: G = __r_arr[0];
                 let __v_61: G = G::from_u64(0);
                 let __v_62: G = G::from_u64(1);
@@ -49629,7 +49629,7 @@ fn aiur_fn_574(
                 }
                 let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } };
                 let __v_72: G = __r_arr[0];
-                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_72, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_72, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
                 let __v_73: G = __r_arr[0];
                 let __v_74: G = G::from_u64(1);
                 if (__v_73 != __v_74) {
@@ -49765,7 +49765,7 @@ fn aiur_fn_576(
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
@@ -50015,7 +50015,7 @@ fn aiur_fn_580(
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -50254,7 +50254,7 @@ fn aiur_fn_584(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } };
     let __v_0: G = __r_arr[0];
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
@@ -50312,7 +50312,7 @@ fn aiur_fn_585(
   0u64 => {
     let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = G::from_u64(1);
     if (__v_5 != __v_6) {
@@ -50325,7 +50325,7 @@ fn aiur_fn_585(
   1u64 => {
     let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = G::from_u64(1);
     if (__v_5 != __v_6) {
@@ -50339,7 +50339,7 @@ fn aiur_fn_585(
     let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } };
     let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = G::from_u64(1);
     if (__v_5 != __v_6) {
@@ -50352,7 +50352,7 @@ fn aiur_fn_585(
   3u64 => {
     let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = G::from_u64(1);
     if (__v_5 != __v_6) {
@@ -50568,7 +50568,7 @@ fn aiur_fn_589(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
@@ -50585,7 +50585,7 @@ fn aiur_fn_589(
     let __v_15: G = __loaded[11];
     match __v_4.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __v_17: G = G::from_u64(1);
         if (__v_16 != __v_17) {
@@ -50625,7 +50625,7 @@ fn aiur_fn_590(
     let __v_7: G = (__v_1 + __v_3);
     let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_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 };
@@ -50839,7 +50839,7 @@ fn aiur_fn_594(
       5u64 => {
         let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         if (__v_8 != __v_9) {
@@ -50956,7 +50956,7 @@ fn aiur_fn_597(
   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_288] = { let __args: [G; IN_288] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __ret: [G; OUT_597] = [__v_2];
     if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -50988,7 +50988,7 @@ fn aiur_fn_598(
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
@@ -51025,7 +51025,7 @@ fn aiur_fn_599(
   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_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
@@ -51378,7 +51378,7 @@ fn aiur_fn_604(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_6: G = __loaded[0];
@@ -51470,7 +51470,7 @@ fn aiur_fn_605(
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_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 };
@@ -51501,7 +51501,7 @@ fn aiur_fn_605(
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
                     let __v_17: G = __r_arr[0];
                     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                     let __v_18: G = __loaded[0];
@@ -51581,7 +51581,7 @@ fn aiur_fn_606(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
@@ -51756,7 +51756,7 @@ fn aiur_fn_610(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_12: G = __loaded[0];
@@ -51789,7 +51789,7 @@ fn aiur_fn_610(
   },
 }
  };
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_24: G = __r_arr[0];
             let __v_25: G = G::from_u64(1);
             if (__v_24 != __v_25) {
@@ -51883,7 +51883,7 @@ fn aiur_fn_612(
     let __v_12: G = inp[12];
     match __v_0.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         match __v_13.as_canonical_u64() {
           1u64 => {
@@ -51892,7 +51892,7 @@ fn aiur_fn_612(
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
             let __v_16: G = __r_arr[2];
@@ -52057,7 +52057,7 @@ fn aiur_fn_613(
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
                 let __v_56: G = __r_arr[0];
                 let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                 let __v_57: G = __loaded[0];
@@ -52090,7 +52090,7 @@ fn aiur_fn_613(
                     if (__v_60 != __v_2) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) });
                     }
-                    let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
                     let __v_79: G = __r_arr[0];
                     let __v_80: G = G::from_u64(1);
                     if (__v_79 != __v_80) {
@@ -52158,7 +52158,7 @@ fn aiur_fn_614(
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
     let __v_15: G = inp[15];
-    let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
     match __v_16.as_canonical_u64() {
       1u64 => {
@@ -52311,7 +52311,7 @@ fn aiur_fn_616(
     let __v_5: G = (__v_1 - __v_2);
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } };
@@ -52334,7 +52334,7 @@ fn aiur_fn_616(
             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_323] = { let __args: [G; IN_323] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
             let __v_16: G = (__v_11 - __v_15);
             let __v_17: G = G::from_u64(1);
@@ -52531,7 +52531,7 @@ fn aiur_fn_619(
             let __v_19: G = G::from_u64(0);
             let __v_20: G = G::from_u64(0);
             let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
             match __v_22.as_canonical_u64() {
               0u64 => {
@@ -52544,7 +52544,7 @@ fn aiur_fn_619(
                 match __v_5.as_canonical_u64() {
                   1u64 => {
                     let __v_23: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
                     let __v_24: G = __r_arr[0];
                     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                     let __v_25: G = __loaded[0];
@@ -52608,7 +52608,7 @@ fn aiur_fn_620(
   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_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
@@ -52618,7 +52618,7 @@ fn aiur_fn_620(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -52703,7 +52703,7 @@ fn aiur_fn_621(
 ) -> Result<[G; OUT_621], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -52904,7 +52904,7 @@ fn aiur_fn_623(
     let __v_12: G = __loaded[3];
     match __v_9.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0];
         let __v_14: 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_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -52966,7 +52966,7 @@ fn aiur_fn_624(
         let __v_19: G = __loaded[3];
         match __v_16.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_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 };
@@ -53040,7 +53040,7 @@ fn aiur_fn_625(
     let __v_13: G = __loaded[3];
     match __v_10.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
@@ -53165,7 +53165,7 @@ fn aiur_fn_628(
   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_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -53226,7 +53226,7 @@ fn aiur_fn_628(
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
             let __v_50: G = __r_arr[0];
             let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_51: G = __loaded[0];
@@ -53350,9 +53350,9 @@ fn aiur_fn_629(
       0u64 => {
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
             let __v_52: G = __r_arr[0];
-            let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
             let __v_53: G = __r_arr[0];
             let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_54: G = __loaded[0];
@@ -53443,7 +53443,7 @@ fn aiur_fn_630(
       0u64 => {
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               1u64 => {
@@ -53557,7 +53557,7 @@ fn aiur_fn_631(
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 let __ret: [G; OUT_631] = [__v_11];
                 if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -53579,7 +53579,7 @@ fn aiur_fn_631(
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
@@ -53761,7 +53761,7 @@ fn aiur_fn_631(
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               7u64 => {
-                let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 let __ret: [G; OUT_631] = [__v_11];
                 if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -53783,7 +53783,7 @@ fn aiur_fn_631(
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               8u64 => {
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
@@ -53879,7 +53879,7 @@ fn aiur_fn_632(
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
@@ -54044,7 +54044,7 @@ fn aiur_fn_635(
   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_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -54187,9 +54187,9 @@ fn aiur_fn_636(
       0u64 => {
         match __v_6.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
             let __v_52: G = __r_arr[0];
-            let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
             let __v_53: G = __r_arr[0];
             let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_54: G = __loaded[0];
@@ -54208,7 +54208,7 @@ fn aiur_fn_636(
               7u64 => {
                 let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } };
                 let __v_66: G = __r_arr[0];
-                let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
                 let __v_67: G = __r_arr[0];
                 let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_67.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                 let __v_68: G = __loaded[0];
@@ -54274,7 +54274,7 @@ fn aiur_fn_637(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -54340,7 +54340,7 @@ fn aiur_fn_637(
 }
  };
     let __v_51: G = __mc_out___mc_0[0];
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_52: G = __r_arr[0];
     let __v_53: G = __r_arr[1];
     let __v_54: G = __r_arr[2];
@@ -54399,7 +54399,7 @@ fn aiur_fn_637(
         break '__mc_1 [__v_101];
       },
       _ => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_100: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_101: G = __loaded[0];
@@ -54476,7 +54476,7 @@ fn aiur_fn_638(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     let __v_6: G = __r_arr[2];
@@ -54621,9 +54621,9 @@ fn aiur_fn_639(
       0u64 => {
         match __v_8.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
             let __v_54: G = __r_arr[0];
-            let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
             let __v_55: G = __r_arr[0];
             let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_56: G = __loaded[0];
@@ -54642,7 +54642,7 @@ fn aiur_fn_639(
   7u64 => {
     let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } };
     let __v_68: G = __r_arr[0];
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_69: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_70: G = __loaded[0];
@@ -54659,7 +54659,7 @@ fn aiur_fn_639(
     let __v_81: G = __loaded[11];
     match __v_70.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_77, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_77, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_82: G = __r_arr[0];
         match __v_82.as_canonical_u64() {
           1u64 => {
@@ -54787,7 +54787,7 @@ fn aiur_fn_640(
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         match __v_9.as_canonical_u64() {
           1u64 => {
@@ -54846,7 +54846,7 @@ fn aiur_fn_641(
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = (__v_2 - __v_7);
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_12.as_canonical_u64() {
@@ -55606,7 +55606,7 @@ fn aiur_fn_655(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = G::from_u64(0);
     let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } } else { aiur_fn_644(__args, record, io_buffer, __cu)? } };
@@ -55775,7 +55775,7 @@ fn aiur_fn_659(
     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_286] = { let __args: [G; IN_286] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_15: G = __loaded[0];
@@ -55835,7 +55835,7 @@ fn aiur_fn_660(
     let __v_12: G = G::from_u64(0);
     let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
     let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
@@ -55851,7 +55851,7 @@ fn aiur_fn_660(
     let __v_21: G = __r_arr[1];
     let __v_22: G = __r_arr[2];
     let __v_23: G = __r_arr[3];
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_24: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_25: G = __loaded[0];
@@ -55868,7 +55868,7 @@ fn aiur_fn_660(
     let __v_36: G = __loaded[11];
     match __v_25.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_27, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_27, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
         let __v_38: G = G::from_u64(0);
         let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } } else { aiur_fn_644(__args, record, io_buffer, __cu)? } };
@@ -55991,7 +55991,7 @@ fn aiur_fn_661(
             let __mc_out___mc_0: [G; 13] = '__mc_0: { match __v_18.as_canonical_u64() {
   1u64 => {
     let __v_26: G = G::from_u64(0);
-    let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
     let __v_27: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_28: G = __loaded[0];
@@ -56079,7 +56079,7 @@ fn aiur_fn_661(
             let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } };
             let __v_53: G = __r_arr[0];
             let __v_54: G = G::from_u64(1);
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_55: G = __r_arr[0];
             let __v_56: G = (__v_54 - __v_55);
             let __v_57: G = (__v_53 * __v_56);
@@ -56250,7 +56250,7 @@ fn aiur_fn_663(
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_11: G = __loaded[0];
@@ -56330,7 +56330,7 @@ fn aiur_fn_664(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_17: G = __loaded[0];
@@ -56408,7 +56408,7 @@ fn aiur_fn_665(
       0u64 => {
         match __v_10.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
             let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_15: G = __loaded[0];
@@ -56616,12 +56616,12 @@ fn aiur_fn_666(
         let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
         let __v_87: G = __r_arr[0];
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_88: G = __r_arr[0];
         let __v_89: G = __r_arr[1];
         let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
         let __v_90: G = __r_arr[0];
-        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
         let __v_91: G = __r_arr[0];
         let __v_92: G = G::from_u64(1);
         let __v_93: G = (__v_9 - __v_92);
@@ -56679,7 +56679,7 @@ fn aiur_fn_667(
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
@@ -56791,7 +56791,7 @@ fn aiur_fn_669(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     let __v_7: G = __r_arr[2];
@@ -56937,9 +56937,9 @@ fn aiur_fn_670(
       0u64 => {
         match __v_9.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
             let __v_55: G = __r_arr[0];
-            let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
             let __v_56: G = __r_arr[0];
             let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_57: G = __loaded[0];
@@ -56958,7 +56958,7 @@ fn aiur_fn_670(
   7u64 => {
     let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } };
     let __v_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_70: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_71: G = __loaded[0];
@@ -56984,7 +56984,7 @@ fn aiur_fn_670(
 }
  };
     let __v_83: G = __mc_out___mc_1[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_69, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_69, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_84: G = __r_arr[0];
     match __v_84.as_canonical_u64() {
       1u64 => {
@@ -57078,7 +57078,7 @@ fn aiur_fn_671(
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -57132,7 +57132,7 @@ fn aiur_fn_672(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -57141,7 +57141,7 @@ fn aiur_fn_672(
     let __v_8: G = __r_arr[5];
     let __v_9: G = __r_arr[6];
     let __v_10: G = __r_arr[7];
-    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -57164,9 +57164,9 @@ fn aiur_fn_672(
     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_72] = { let __args: [G; IN_72] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __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_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __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_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_34: G = __r_arr[0];
     let __ret: [G; OUT_672] = [__v_34];
     if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -57210,7 +57210,7 @@ fn aiur_fn_673(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_17: G = __loaded[0];
@@ -57312,7 +57312,7 @@ fn aiur_fn_675(
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_15: G = __loaded[0];
@@ -57566,7 +57566,7 @@ fn aiur_fn_679(
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
-    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     let __v_14: G = (__v_9 + __v_10);
     let __v_15: G = (__v_8 + __v_14);
@@ -57595,7 +57595,7 @@ fn aiur_fn_679(
     let __v_34: G = __r_arr[0];
     let __v_35: G = (__v_33 + __v_34);
     let __v_36: G = (__v_15 + __v_35);
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_37: G = __r_arr[0];
     let __v_38: G = __r_arr[1];
     let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
@@ -57610,7 +57610,7 @@ fn aiur_fn_679(
     let __v_46: G = G::from_u64(0);
     let __v_47: G = G::from_u64(0);
     let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
     let __v_49: G = __r_arr[0];
     let __v_50: G = G::from_u64(2);
     let __v_51: G = G::from_u64(0);
@@ -57764,7 +57764,7 @@ fn aiur_fn_682(
         let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_38: G = __r_arr[0];
         let __v_39: G = __r_arr[1];
         let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
@@ -57772,7 +57772,7 @@ fn aiur_fn_682(
         let __v_41: G = G::from_u64(0);
         let __v_42: G = G::from_u64(0);
         let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
         let __v_44: G = __r_arr[0];
         let __v_45: G = G::from_u64(0);
         let __v_46: G = G::from_u64(0);
@@ -57983,7 +57983,7 @@ fn aiur_fn_687(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_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 };
@@ -58045,7 +58045,7 @@ fn aiur_fn_688(
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() {
   0u64 => {
@@ -58264,7 +58264,7 @@ fn aiur_fn_691(
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_11: G = __loaded[0];
@@ -58339,7 +58339,7 @@ fn aiur_fn_692(
       7u64 => {
         let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_15: G = __loaded[0];
@@ -58361,7 +58361,7 @@ fn aiur_fn_692(
             let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
             let __v_29: G = G::from_u64(1);
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_30: G = __r_arr[0];
             let __v_31: G = (__v_29 - __v_30);
             let __v_32: G = (__v_28 * __v_31);
@@ -58449,7 +58449,7 @@ fn aiur_fn_693(
     let __v_13: G = __loaded[3];
     match __v_10.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
@@ -58679,7 +58679,7 @@ fn aiur_fn_697(
         let __v_20: G = G::from_u64(0);
         let __v_21: G = G::from_u64(0);
         let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
         let __v_24: G = G::from_u64(1);
         if (__v_23 != __v_24) {
@@ -58752,7 +58752,7 @@ fn aiur_fn_697(
         let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
         let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_20: G = __loaded[0];
@@ -58836,7 +58836,7 @@ fn aiur_fn_698(
 ) -> Result<[G; OUT_698], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
@@ -58891,7 +58891,7 @@ fn aiur_fn_699(
     match __v_1.as_canonical_u64() {
       2u64 => {
         let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __v_21: G = G::from_u64(1);
         let __v_22: G = G::from_u64(1);
@@ -58903,7 +58903,7 @@ fn aiur_fn_699(
       },
       4u64 => {
         let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
@@ -59488,7 +59488,7 @@ fn aiur_fn_706(
 ) -> Result<[G; OUT_706], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -59791,9 +59791,9 @@ fn aiur_fn_709(
     let __v_45: G = inp[45];
     let __v_46: G = inp[46];
     let __v_47: G = inp[47];
-    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
     let __v_48: G = __r_arr[0];
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_49: G = __r_arr[0];
     let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_50: G = __loaded[0];
@@ -59829,12 +59829,12 @@ fn aiur_fn_710(
     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_47] = { let __args: [G; IN_47] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { 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_48] = { let __args: [G; IN_48] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { 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_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_21] = { let __args: [G; IN_21] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_8: G = __r_arr[0];
     let __ret: [G; OUT_710] = [__v_8];
     if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -59857,14 +59857,14 @@ fn aiur_fn_711(
     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_47] = { let __args: [G; IN_47] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { 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_48] = { let __args: [G; IN_48] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { 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_48] = { let __args: [G; IN_48] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { 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_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_21] = { let __args: [G; IN_21] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_711] = [__v_10];
     if let Some(result) = record.function_queries[711].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -59883,12 +59883,12 @@ fn aiur_fn_712(
 ) -> Result<[G; OUT_712], 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
     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_88] = { let __args: [G; IN_88] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
@@ -60016,9 +60016,9 @@ fn aiur_fn_713(
     let __v_34: G = __io_pair.0;
     let __v_35: G = __io_pair.1;
     let __v_36: G = G::from_u64(1);
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } };
     let __v_37: G = __r_arr[0];
-    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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_78] = { let __args: [G; IN_78] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { 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_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -60319,7 +60319,7 @@ fn aiur_fn_716(
   },
 }
  };
-        let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
         let __v_15: G = __r_arr[0];
         let __v_16: G = __r_arr[1];
         let __v_17: G = __r_arr[2];
@@ -60612,7 +60612,7 @@ fn aiur_fn_720(
 ) -> Result<[G; OUT_720], 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     match __v_1.as_canonical_u64() {
@@ -60624,7 +60624,7 @@ fn aiur_fn_720(
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = G::from_u64(0);
@@ -60660,7 +60660,7 @@ fn aiur_fn_721(
         return Ok(__ret);
       },
       _ => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -60700,7 +60700,7 @@ fn aiur_fn_722(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = G::from_u64(0);
@@ -60733,7 +60733,7 @@ fn aiur_fn_723(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = G::from_u64(0);
@@ -60766,7 +60766,7 @@ fn aiur_fn_724(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         match __v_2.as_canonical_u64() {
@@ -60821,7 +60821,7 @@ fn aiur_fn_725(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         match __v_2.as_canonical_u64() {
@@ -60881,7 +60881,7 @@ fn aiur_fn_726(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
@@ -60893,7 +60893,7 @@ fn aiur_fn_726(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -60912,7 +60912,7 @@ fn aiur_fn_726(
         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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { 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_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -60955,7 +60955,7 @@ fn aiur_fn_727(
         return Ok(__ret);
       },
       _ => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -60988,7 +60988,7 @@ fn aiur_fn_728(
 ) -> Result<[G; OUT_728], 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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];
@@ -61076,7 +61076,7 @@ fn aiur_fn_729(
 ) -> Result<[G; OUT_729], 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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];
@@ -61153,7 +61153,7 @@ fn aiur_fn_730(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
@@ -61215,7 +61215,7 @@ fn aiur_fn_730(
         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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { 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_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
         let __v_59: G = __r_arr[0];
         let __v_60: G = __r_arr[1];
         let __v_61: G = __r_arr[2];
@@ -61258,7 +61258,7 @@ fn aiur_fn_731(
         return Ok(__ret);
       },
       _ => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -61291,10 +61291,10 @@ fn aiur_fn_732(
 ) -> Result<[G; OUT_732], 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -61504,7 +61504,7 @@ fn aiur_fn_733(
 ) -> Result<[G; OUT_733], 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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];
@@ -61595,7 +61595,7 @@ fn aiur_fn_734(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
@@ -61671,7 +61671,7 @@ fn aiur_fn_734(
         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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { 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_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
         let __v_73: G = __r_arr[0];
         let __v_74: G = __r_arr[1];
         let __v_75: G = __r_arr[2];
@@ -61704,10 +61704,10 @@ fn aiur_fn_735(
 ) -> Result<[G; OUT_735], 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { 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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -62007,7 +62007,7 @@ fn aiur_fn_735(
     break '__mc_0 [__v_30, __v_11];
   },
   1u64 => {
-    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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { 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_76] = { let __args: [G; IN_76] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { 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_28: G = __r_arr[0];
     let __v_29: G = __r_arr[1];
     let __v_30: G = __r_arr[2];
@@ -62075,9 +62075,9 @@ fn aiur_fn_736(
     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_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_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[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_21] = { let __args: [G; IN_21] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_23: G = __r_arr[0];
     let __ret: [G; OUT_736] = [__v_23];
     if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -62218,9 +62218,9 @@ fn aiur_fn_740(
         return Ok(__ret);
       },
       0u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { 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_4: G = __r_arr[0];
         if (__v_3 != __v_4) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed quotient kind != real".to_string()) });
@@ -62861,7 +62861,7 @@ fn aiur_fn_745(
                     if (__v_37 != __v_26) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
                     }
-                    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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { 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_15] = { let __args: [G; IN_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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
                     let __v_41: G = __r_arr[0];
                     let __v_42: G = __r_arr[1];
                     let __v_43: G = __r_arr[2];
@@ -63553,7 +63553,7 @@ fn aiur_fn_752(
     let __v_52: G = inp[52];
     let __v_53: G = inp[53];
     let __v_54: G = inp[54];
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
     let __v_55: G = __r_arr[0];
     let __v_56: G = __r_arr[1];
     let __v_57: G = __r_arr[2];
@@ -63833,7 +63833,7 @@ fn aiur_fn_754(
     let __v_9: G = __io_pair.0;
     let __v_10: G = __io_pair.1;
     let __v_11: G = G::from_u64(0);
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __v_9, __v_10]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_11, __v_9, __v_10]; let __cu = true; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
     let __v_13: G = G::from_u64(103);
     let __v_14: G = G::from_u64(230);
@@ -63885,9 +63885,9 @@ fn aiur_fn_754(
     let __v_60: G = G::from_u64(1);
     let __v_61: G = G::from_u64(1);
     let __v_62: G = { let __values: [G; 34] = [__v_60, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61]; 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_24] = { let __args: [G; IN_24] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { 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_25] = { let __args: [G; IN_25] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_63: G = __r_arr[0];
-    let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_24] = { let __args: [G; IN_24] = [__v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
     let __v_64: G = __r_arr[0];
     let __v_65: G = __r_arr[1];
     let __v_66: G = __r_arr[2];
@@ -63920,7 +63920,7 @@ fn aiur_fn_754(
     let __v_93: G = __r_arr[29];
     let __v_94: G = __r_arr[30];
     let __v_95: G = __r_arr[31];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_78] = { let __args: [G; IN_78] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { 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_96: G = __r_arr[0];
     let __v_97: G = __r_arr[1];
     let __v_98: G = __r_arr[2];
@@ -64043,7 +64043,7 @@ fn aiur_fn_754(
     }
     match __v_97.as_canonical_u64() {
       4u64 => {
-        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { 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_186: G = __r_arr[0];
         let __v_187: G = __r_arr[1];
         let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } };
@@ -64083,7 +64083,7 @@ fn aiur_fn_754(
         }
       },
       5u64 => {
-        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { 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_186: G = __r_arr[0];
         let __v_187: G = __r_arr[1];
         let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } };
@@ -64096,7 +64096,7 @@ fn aiur_fn_754(
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { 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_186: G = __r_arr[0];
         let __v_187: G = __r_arr[1];
         let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } };
@@ -64161,10 +64161,10 @@ fn aiur_fn_754(
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { 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_186: G = __r_arr[0];
         let __v_187: G = __r_arr[1];
-        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_89(__args, record, io_buffer, false)? } else { 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_188: G = __r_arr[0];
         let __v_189: G = __r_arr[1];
         let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_186, __v_188]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } };
@@ -64330,7 +64330,7 @@ fn aiur_fn_758(
         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_14] = { let __args: [G; IN_14] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { 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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -64428,7 +64428,7 @@ fn aiur_fn_760(
         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_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { 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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -64692,7 +64692,7 @@ fn aiur_fn_765(
         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_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { 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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_45: G = __r_arr[0];
         let __v_46: G = __r_arr[1];
         let __v_47: G = __r_arr[2];
@@ -64857,7 +64857,7 @@ fn aiur_fn_768(
     let __v_55: G = __loaded[46];
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_56: G = __r_arr[0];
         match __v_56.as_canonical_u64() {
           1u64 => {
@@ -64866,7 +64866,7 @@ fn aiur_fn_768(
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { 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_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
             let __v_57: G = __r_arr[0];
             let __v_58: G = __r_arr[1];
             let __v_59: G = __r_arr[2];
@@ -65020,7 +65020,7 @@ fn aiur_fn_769(
         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_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { 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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
         let __v_57: G = __r_arr[1];
         let __v_58: G = __r_arr[2];
@@ -65087,7 +65087,7 @@ fn aiur_fn_770(
         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_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { 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_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -65165,7 +65165,7 @@ fn aiur_fn_771(
     let __v_44: G = __loaded[35];
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__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[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { 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_45: G = __r_arr[0];
         match __v_45.as_canonical_u64() {
           1u64 => {
@@ -65174,7 +65174,7 @@ fn aiur_fn_771(
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { 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_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
             let __v_46: G = __r_arr[0];
             let __v_47: G = __r_arr[1];
             let __v_48: G = __r_arr[2];
diff --git a/crates/ixvm-codegen/src/aiur_ixvm_witness.rs b/crates/ixvm-codegen/src/aiur_ixvm_witness.rs
index a194b0f94..67d3a95c5 100644
--- a/crates/ixvm-codegen/src/aiur_ixvm_witness.rs
+++ b/crates/ixvm-codegen/src/aiur_ixvm_witness.rs
@@ -75,7 +75,9 @@ fn addr_key(addr: &Address) -> Vec<G> {
 fn packed_digest_key(addr: &Address) -> Vec<G> {
   addr
     .as_bytes()
-    .chunks_exact(4)
+    .as_chunks::<4>()
+    .0
+    .iter()
     .map(|w| {
       G::from_u32(
         u32::from(w[0])
diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs
index 051a10e1a..15e6ebc8a 100644
--- a/crates/ixvm-codegen/src/aiur_multi_stark.rs
+++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs
@@ -16,8 +16,8 @@ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};
 use aiur::G;
 use aiur::execute::{ ExecError, IOBuffer, QueryRecord, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_less_than_value, bytes2_xor_split7_value, bytes2_xor_split4_value, g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 };
 
-const INPUT_SIZE_0: usize = 3;
-const IN_0: usize = 3;
+const INPUT_SIZE_0: usize = 2;
+const IN_0: usize = 2;
 const OUT_0: usize = 1;
 fn aiur_fn_0(
   inp: [G; IN_0],
@@ -25,6 +25,25 @@ fn aiur_fn_0(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_0], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+    let __ret: [G; OUT_0] = [__v_2];
+    if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_1: usize = 3;
+const IN_1: usize = 3;
+const OUT_1: usize = 1;
+fn aiur_fn_1(
+  inp: [G; IN_1],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_1], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -34,8 +53,8 @@ fn aiur_fn_0(
         let __v_3: G = G::from_u64(1);
         let __v_4: G = G::from_u64(1);
         let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_0] = [__v_5];
-        if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_1] = [__v_5];
+        if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -43,29 +62,29 @@ fn aiur_fn_0(
         let __v_4: G = (__v_1 + __v_3);
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_2 - __v_5);
-        let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr };
         let __v_8: G = __io_read[0];
         let __v_9: G = G::from_u64(0);
         let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_0] = [__v_10];
-        if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_1] = [__v_10];
+        if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_1: usize = 8;
-const IN_1: usize = 8;
-const OUT_1: usize = 1;
-fn aiur_fn_1(
-  inp: [G; IN_1],
+const INPUT_SIZE_2: usize = 8;
+const IN_2: usize = 8;
+const OUT_2: usize = 1;
+fn aiur_fn_2(
+  inp: [G; IN_2],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_1], ExecError> {
+) -> Result<[G; OUT_2], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -92,85 +111,85 @@ fn aiur_fn_1(
                                 match __v_7.as_canonical_u64() {
                                   0u64 => {
                                     let __v_8: G = G::from_u64(1);
-                                    let __ret: [G; OUT_1] = [__v_8];
-                                    if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_2] = [__v_8];
+                                    if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                   _ => {
                                     let __v_8: G = G::from_u64(0);
-                                    let __ret: [G; OUT_1] = [__v_8];
-                                    if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_2] = [__v_8];
+                                    if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(0);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_2] = [__v_8];
+                                if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
                             let __v_8: G = G::from_u64(0);
-                            let __ret: [G; OUT_1] = [__v_8];
-                            if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_2] = [__v_8];
+                            if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_8: G = G::from_u64(0);
-                        let __ret: [G; OUT_1] = [__v_8];
-                        if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_2] = [__v_8];
+                        if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_8: G = G::from_u64(0);
-                    let __ret: [G; OUT_1] = [__v_8];
-                    if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_2] = [__v_8];
+                    if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_8: G = G::from_u64(0);
-                let __ret: [G; OUT_1] = [__v_8];
-                if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_2] = [__v_8];
+                if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_1] = [__v_8];
-            if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_2] = [__v_8];
+            if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_1] = [__v_8];
-        if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_2] = [__v_8];
+        if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_2: usize = 8;
-const IN_2: usize = 8;
-const OUT_2: usize = 4;
-fn aiur_fn_2(
-  inp: [G; IN_2],
+const INPUT_SIZE_3: usize = 8;
+const IN_3: usize = 8;
+const OUT_3: usize = 4;
+fn aiur_fn_3(
+  inp: [G; IN_3],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_2], ExecError> {
+) -> Result<[G; OUT_3], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -193,21 +212,21 @@ fn aiur_fn_2(
     if (__v_13 != __v_12) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
     }
-    let __ret: [G; OUT_2] = [__v_8, __v_9, __v_10, __v_11];
-    if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_3] = [__v_8, __v_9, __v_10, __v_11];
+    if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_3: usize = 12;
-const IN_3: usize = 12;
-const OUT_3: usize = 4;
-fn aiur_fn_3(
-  inp: [G; IN_3],
+const INPUT_SIZE_4: usize = 12;
+const IN_4: usize = 12;
+const OUT_4: usize = 4;
+fn aiur_fn_4(
+  inp: [G; IN_4],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_3], ExecError> {
+) -> 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];
@@ -240,21 +259,21 @@ fn aiur_fn_3(
     if (__v_22 != __v_23) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
     }
-    let __ret: [G; OUT_3] = [__v_12, __v_13, __v_14, __v_15];
-    if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_4] = [__v_12, __v_13, __v_14, __v_15];
+    if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_4: usize = 8;
-const IN_4: usize = 8;
-const OUT_4: usize = 4;
-fn aiur_fn_4(
-  inp: [G; IN_4],
+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_4], 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];
@@ -268,27 +287,7 @@ fn aiur_fn_4(
     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];
-    if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_5: usize = 4;
-const IN_5: usize = 4;
-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 __ret: [G; OUT_5] = [__v_2, __v_3, __v_0, __v_1];
+    let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11];
     if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
@@ -308,14 +307,14 @@ fn aiur_fn_6(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __ret: [G; OUT_6] = [__v_1, __v_2, __v_3, __v_0];
+    let __ret: [G; OUT_6] = [__v_2, __v_3, __v_0, __v_1];
     if let Some(result) = record.function_queries[6].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_7: usize = 8;
-const IN_7: usize = 8;
+const INPUT_SIZE_7: usize = 4;
+const IN_7: usize = 4;
 const OUT_7: usize = 4;
 fn aiur_fn_7(
   inp: [G; IN_7],
@@ -323,6 +322,26 @@ fn aiur_fn_7(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_7], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __ret: [G; OUT_7] = [__v_1, __v_2, __v_3, __v_0];
+    if let Some(result) = record.function_queries[7].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_8: usize = 8;
+const IN_8: usize = 8;
+const OUT_8: usize = 4;
+fn aiur_fn_8(
+  inp: [G; IN_8],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_8], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -348,21 +367,21 @@ fn aiur_fn_7(
     let __v_17: G = (__v_10 + __v_13);
     let __v_18: G = (__v_12 + __v_15);
     let __v_19: G = (__v_14 + __v_9);
-    let __ret: [G; OUT_7] = [__v_16, __v_17, __v_18, __v_19];
-    if let Some(result) = record.function_queries[7].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_8] = [__v_16, __v_17, __v_18, __v_19];
+    if let Some(result) = record.function_queries[8].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_8: usize = 8;
-const IN_8: usize = 8;
-const OUT_8: usize = 4;
-fn aiur_fn_8(
-  inp: [G; IN_8],
+const INPUT_SIZE_9: usize = 8;
+const IN_9: usize = 8;
+const OUT_9: usize = 4;
+fn aiur_fn_9(
+  inp: [G; IN_9],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_8], 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];
@@ -388,21 +407,21 @@ fn aiur_fn_8(
     let __v_17: G = (__v_12 + __v_15);
     let __v_18: G = (__v_14 + __v_9);
     let __v_19: G = (__v_8 + __v_11);
-    let __ret: [G; OUT_8] = [__v_16, __v_17, __v_18, __v_19];
-    if let Some(result) = record.function_queries[8].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_9] = [__v_16, __v_17, __v_18, __v_19];
+    if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_9: usize = 8;
-const IN_9: usize = 8;
-const OUT_9: usize = 8;
-fn aiur_fn_9(
-  inp: [G; IN_9],
+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_9], 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];
@@ -436,8 +455,8 @@ fn aiur_fn_9(
                                     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_9] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-                                    if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].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];
+                                    if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -450,8 +469,8 @@ fn aiur_fn_9(
                                     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_9] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
-                                    if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].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];
+                                    if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                 }
@@ -465,8 +484,8 @@ fn aiur_fn_9(
                                 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_9] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
-                                if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].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];
+                                if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
@@ -479,8 +498,8 @@ fn aiur_fn_9(
                             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_9] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
-                            if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].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];
+                            if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                         }
@@ -492,8 +511,8 @@ fn aiur_fn_9(
                         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_9] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
-                        if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].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];
+                        if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
@@ -504,8 +523,8 @@ fn aiur_fn_9(
                     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_9] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
-                    if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].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];
+                    if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
@@ -515,8 +534,8 @@ fn aiur_fn_9(
                 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_9] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
-                if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].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];
+                if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -525,8 +544,8 @@ fn aiur_fn_9(
             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_9] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-            if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].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];
+            if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -534,23 +553,23 @@ fn aiur_fn_9(
       _ => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_0 + __v_8);
-        let __ret: [G; OUT_9] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-        if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].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];
+        if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].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 = 1;
-fn aiur_fn_10(
-  inp: [G; IN_10],
+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_10], 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];
@@ -582,21 +601,21 @@ fn aiur_fn_10(
     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_10] = [__v_26];
-    if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_11] = [__v_26];
+    if let Some(result) = record.function_queries[11].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_11: usize = 8;
-const IN_11: usize = 8;
-const OUT_11: usize = 1;
-fn aiur_fn_11(
-  inp: [G; IN_11],
+const INPUT_SIZE_12: usize = 8;
+const IN_12: usize = 8;
+const OUT_12: usize = 1;
+fn aiur_fn_12(
+  inp: [G; IN_12],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_11], ExecError> {
+) -> 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];
@@ -627,21 +646,21 @@ fn aiur_fn_11(
     let __v_26: G = (__v_11 + __v_25);
     let __v_27: G = (__v_9 + __v_26);
     let __v_28: G = (__v_0 + __v_27);
-    let __ret: [G; OUT_11] = [__v_28];
-    if let Some(result) = record.function_queries[11].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_12] = [__v_28];
+    if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].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 = 1;
-fn aiur_fn_12(
-  inp: [G; IN_12],
+const INPUT_SIZE_13: usize = 8;
+const IN_13: usize = 8;
+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_12], ExecError> {
+) -> Result<[G; OUT_13], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -666,21 +685,21 @@ fn aiur_fn_12(
     let __v_20: G = (__v_19 - __v_17);
     let __v_21: G = (__v_13 * __v_20);
     let __v_22: G = (__v_18 - __v_21);
-    let __ret: [G; OUT_12] = [__v_22];
-    if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_13] = [__v_22];
+    if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_13: usize = 1;
-const IN_13: usize = 1;
-const OUT_13: usize = 8;
-fn aiur_fn_13(
-  inp: [G; IN_13],
+const INPUT_SIZE_14: usize = 1;
+const IN_14: usize = 1;
+const OUT_14: usize = 8;
+fn aiur_fn_14(
+  inp: [G; IN_14],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_13], ExecError> {
+) -> Result<[G; OUT_14], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes();
@@ -739,21 +758,21 @@ fn aiur_fn_13(
     if (__v_44 != __v_45) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None });
     }
-    let __ret: [G; OUT_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-    if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+    if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_14: usize = 1;
-const IN_14: usize = 1;
-const OUT_14: usize = 1;
-fn aiur_fn_14(
-  inp: [G; IN_14],
+const INPUT_SIZE_15: usize = 1;
+const IN_15: usize = 1;
+const OUT_15: usize = 1;
+fn aiur_fn_15(
+  inp: [G; IN_15],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_14], ExecError> {
+) -> Result<[G; OUT_15], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = g_inverse_value(__v_0);
@@ -770,21 +789,21 @@ fn aiur_fn_14(
     if (__v_7 != __v_8) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
     }
-    let __ret: [G; OUT_14] = [__v_1];
-    if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_15] = [__v_1];
+    if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_15: usize = 4;
-const IN_15: usize = 4;
-const OUT_15: usize = 2;
-fn aiur_fn_15(
-  inp: [G; IN_15],
+const INPUT_SIZE_16: usize = 4;
+const IN_16: usize = 4;
+const OUT_16: usize = 2;
+fn aiur_fn_16(
+  inp: [G; IN_16],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_15], ExecError> {
+) -> Result<[G; OUT_16], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -792,21 +811,21 @@ fn aiur_fn_15(
     let __v_3: G = inp[3];
     let __v_4: G = (__v_0 + __v_2);
     let __v_5: G = (__v_1 + __v_3);
-    let __ret: [G; OUT_15] = [__v_4, __v_5];
-    if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_16] = [__v_4, __v_5];
+    if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_16: usize = 4;
-const IN_16: usize = 4;
-const OUT_16: usize = 2;
-fn aiur_fn_16(
-  inp: [G; IN_16],
+const INPUT_SIZE_17: usize = 4;
+const IN_17: usize = 4;
+const OUT_17: usize = 2;
+fn aiur_fn_17(
+  inp: [G; IN_17],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_16], 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];
@@ -814,21 +833,21 @@ fn aiur_fn_16(
     let __v_3: G = inp[3];
     let __v_4: G = (__v_0 - __v_2);
     let __v_5: G = (__v_1 - __v_3);
-    let __ret: [G; OUT_16] = [__v_4, __v_5];
-    if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_17] = [__v_4, __v_5];
+    if let Some(result) = record.function_queries[17].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_17: usize = 2;
-const IN_17: usize = 2;
-const OUT_17: usize = 2;
-fn aiur_fn_17(
-  inp: [G; IN_17],
+const INPUT_SIZE_18: usize = 2;
+const IN_18: usize = 2;
+const OUT_18: usize = 2;
+fn aiur_fn_18(
+  inp: [G; IN_18],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_17], 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];
@@ -836,21 +855,21 @@ fn aiur_fn_17(
     let __v_3: G = (__v_2 - __v_0);
     let __v_4: G = G::from_u64(0);
     let __v_5: G = (__v_4 - __v_1);
-    let __ret: [G; OUT_17] = [__v_3, __v_5];
-    if let Some(result) = record.function_queries[17].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_18] = [__v_3, __v_5];
+    if let Some(result) = record.function_queries[18].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_18: usize = 4;
-const IN_18: usize = 4;
-const OUT_18: usize = 2;
-fn aiur_fn_18(
-  inp: [G; IN_18],
+const INPUT_SIZE_19: usize = 4;
+const IN_19: usize = 4;
+const OUT_19: usize = 2;
+fn aiur_fn_19(
+  inp: [G; IN_19],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_18], 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];
@@ -864,21 +883,21 @@ fn aiur_fn_18(
     let __v_9: G = (__v_0 * __v_3);
     let __v_10: G = (__v_1 * __v_2);
     let __v_11: G = (__v_9 + __v_10);
-    let __ret: [G; OUT_18] = [__v_8, __v_11];
-    if let Some(result) = record.function_queries[18].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_19] = [__v_8, __v_11];
+    if let Some(result) = record.function_queries[19].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_19: usize = 2;
-const IN_19: usize = 2;
-const OUT_19: usize = 2;
-fn aiur_fn_19(
-  inp: [G; IN_19],
+const INPUT_SIZE_20: usize = 2;
+const IN_20: usize = 2;
+const OUT_20: usize = 2;
+fn aiur_fn_20(
+  inp: [G; IN_20],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_19], ExecError> {
+) -> Result<[G; OUT_20], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -905,21 +924,21 @@ fn aiur_fn_19(
     let __v_16: G = G::from_u64(0);
     let __v_17: G = (__v_16 - __v_1);
     let __v_18: G = (__v_17 * __v_7);
-    let __ret: [G; OUT_19] = [__v_15, __v_18];
-    if let Some(result) = record.function_queries[19].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_20] = [__v_15, __v_18];
+    if let Some(result) = record.function_queries[20].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_20: usize = 4;
-const IN_20: usize = 4;
-const OUT_20: usize = 2;
-fn aiur_fn_20(
-  inp: [G; IN_20],
+const INPUT_SIZE_21: usize = 4;
+const IN_21: usize = 4;
+const OUT_21: usize = 2;
+fn aiur_fn_21(
+  inp: [G; IN_21],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_20], 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];
@@ -956,21 +975,21 @@ fn aiur_fn_20(
     let __v_26: G = (__v_0 * __v_20);
     let __v_27: G = (__v_1 * __v_17);
     let __v_28: G = (__v_26 + __v_27);
-    let __ret: [G; OUT_20] = [__v_25, __v_28];
-    if let Some(result) = record.function_queries[20].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_21] = [__v_25, __v_28];
+    if let Some(result) = record.function_queries[21].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_21: usize = 4;
-const IN_21: usize = 4;
-const OUT_21: usize = 1;
-fn aiur_fn_21(
-  inp: [G; IN_21],
+const INPUT_SIZE_22: usize = 4;
+const IN_22: usize = 4;
+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_21], 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];
@@ -981,21 +1000,21 @@ fn aiur_fn_21(
     let __v_6: G = (__v_1 - __v_3);
     let __v_7: G = G::from_bool((__v_6 == G::ZERO));
     let __v_8: G = (__v_5 * __v_7);
-    let __ret: [G; OUT_21] = [__v_8];
-    if let Some(result) = record.function_queries[21].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_22] = [__v_8];
+    if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_22: usize = 1;
-const IN_22: usize = 1;
-const OUT_22: usize = 2;
-fn aiur_fn_22(
-  inp: [G; IN_22],
+const INPUT_SIZE_23: usize = 1;
+const IN_23: usize = 1;
+const OUT_23: usize = 2;
+fn aiur_fn_23(
+  inp: [G; IN_23],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_22], ExecError> {
+) -> Result<[G; OUT_23], 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 };
@@ -1004,8 +1023,8 @@ fn aiur_fn_22(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_22] = [__v_2, __v_3];
-        if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_23] = [__v_2, __v_3];
+        if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
@@ -1013,8 +1032,8 @@ fn aiur_fn_22(
         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_22] = [__v_4, __v_7];
-        if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_23] = [__v_4, __v_7];
+        if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -1024,59 +1043,59 @@ fn aiur_fn_22(
   })
 }
 
-const INPUT_SIZE_23: usize = 1;
-const IN_23: usize = 1;
-const OUT_23: usize = 9;
-fn aiur_fn_23(
-  inp: [G; IN_23],
+const INPUT_SIZE_24: usize = 1;
+const IN_24: usize = 1;
+const OUT_24: usize = 9;
+fn aiur_fn_24(
+  inp: [G; IN_24],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_23], ExecError> {
+) -> Result<[G; OUT_24], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_23] = { let __args: [G; IN_23] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_23] = { let __args: [G; IN_23] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_23] = { let __args: [G; IN_23] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_23] = { let __args: [G; IN_23] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_23] = { let __args: [G; IN_23] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_23] = { let __args: [G; IN_23] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_23] = { let __args: [G; IN_23] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { 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_23] = { let __args: [G; IN_23] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
-    let __ret: [G; OUT_23] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16];
-    if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_24] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16];
+    if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_24: usize = 1;
-const IN_24: usize = 1;
-const OUT_24: usize = 2;
-fn aiur_fn_24(
-  inp: [G; IN_24],
+const INPUT_SIZE_25: usize = 1;
+const IN_25: usize = 1;
+const OUT_25: usize = 2;
+fn aiur_fn_25(
+  inp: [G; IN_25],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_24], ExecError> {
+) -> Result<[G; OUT_25], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -1086,23 +1105,23 @@ fn aiur_fn_24(
     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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_10(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_11(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
-    let __ret: [G; OUT_24] = [__v_10, __v_9];
-    if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_25] = [__v_10, __v_9];
+    if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_25: usize = 1;
-const IN_25: usize = 1;
-const OUT_25: usize = 2;
-fn aiur_fn_25(
-  inp: [G; IN_25],
+const INPUT_SIZE_26: usize = 1;
+const IN_26: usize = 1;
+const OUT_26: usize = 2;
+fn aiur_fn_26(
+  inp: [G; IN_26],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_25], ExecError> {
+) -> Result<[G; OUT_26], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -1110,21 +1129,21 @@ fn aiur_fn_25(
     let __v_2: G = __io_read[0];
     let __v_3: G = G::from_u64(1);
     let __v_4: G = (__v_0 + __v_3);
-    let __ret: [G; OUT_25] = [__v_2, __v_4];
-    if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_26] = [__v_2, __v_4];
+    if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_26: usize = 1;
-const IN_26: usize = 1;
-const OUT_26: usize = 9;
-fn aiur_fn_26(
-  inp: [G; IN_26],
+const INPUT_SIZE_27: usize = 1;
+const IN_27: usize = 1;
+const OUT_27: usize = 9;
+fn aiur_fn_27(
+  inp: [G; IN_27],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_26], ExecError> {
+) -> Result<[G; OUT_27], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -1139,24 +1158,24 @@ fn aiur_fn_26(
     let __v_9: G = __io_read[7];
     let __v_10: G = G::from_u64(8);
     let __v_11: G = (__v_0 + __v_10);
-    let __ret: [G; OUT_26] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11];
-    if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_27] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11];
+    if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_27: usize = 1;
-const IN_27: usize = 1;
-const OUT_27: usize = 2;
-fn aiur_fn_27(
-  inp: [G; IN_27],
+const INPUT_SIZE_28: usize = 1;
+const IN_28: usize = 1;
+const OUT_28: usize = 2;
+fn aiur_fn_28(
+  inp: [G; IN_28],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_27], ExecError> {
+) -> Result<[G; OUT_28], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -1166,26 +1185,26 @@ fn aiur_fn_27(
     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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_10(__args, record, io_buffer, false)? } else { 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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_11(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
-    let __ret: [G; OUT_27] = [__v_10, __v_9];
-    if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_28] = [__v_10, __v_9];
+    if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_28: usize = 1;
-const IN_28: usize = 1;
-const OUT_28: usize = 3;
-fn aiur_fn_28(
-  inp: [G; IN_28],
+const INPUT_SIZE_29: usize = 1;
+const IN_29: usize = 1;
+const OUT_29: usize = 3;
+fn aiur_fn_29(
+  inp: [G; IN_29],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_28], ExecError> {
+) -> Result<[G; OUT_29], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -1195,7 +1214,7 @@ fn aiur_fn_28(
     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_26] = { let __args: [G; IN_26] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -1247,24 +1266,24 @@ fn aiur_fn_28(
     let __v_58: G = (__v_43 + __v_57);
     let __v_59: G = (__v_41 + __v_58);
     let __v_60: G = (__v_10 + __v_59);
-    let __ret: [G; OUT_28] = [__v_39, __v_60, __v_18];
-    if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_29] = [__v_39, __v_60, __v_18];
+    if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_29: usize = 1;
-const IN_29: usize = 1;
-const OUT_29: usize = 33;
-fn aiur_fn_29(
-  inp: [G; IN_29],
+const INPUT_SIZE_30: usize = 1;
+const IN_30: usize = 1;
+const OUT_30: usize = 33;
+fn aiur_fn_30(
+  inp: [G; IN_30],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_29], ExecError> {
+) -> Result<[G; OUT_30], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -1274,7 +1293,7 @@ fn aiur_fn_29(
     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_26] = { let __args: [G; IN_26] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -1284,7 +1303,7 @@ fn aiur_fn_29(
     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_26] = { let __args: [G; IN_26] = [__v_18]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_18]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_19: G = __r_arr[0];
     let __v_20: G = __r_arr[1];
     let __v_21: G = __r_arr[2];
@@ -1294,7 +1313,7 @@ fn aiur_fn_29(
     let __v_25: G = __r_arr[6];
     let __v_26: G = __r_arr[7];
     let __v_27: G = __r_arr[8];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_27]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_27]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_28: G = __r_arr[0];
     let __v_29: G = __r_arr[1];
     let __v_30: G = __r_arr[2];
@@ -1304,44 +1323,44 @@ fn aiur_fn_29(
     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_29] = [__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, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
-    if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_30] = [__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, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+    if let Some(result) = record.function_queries[30].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_30: usize = 1;
-const IN_30: usize = 1;
-const OUT_30: usize = 2;
-fn aiur_fn_30(
-  inp: [G; IN_30],
+const INPUT_SIZE_31: usize = 1;
+const IN_31: usize = 1;
+const OUT_31: usize = 2;
+fn aiur_fn_31(
+  inp: [G; IN_31],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_30], ExecError> {
+) -> Result<[G; OUT_31], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { 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_32] = { let __args: [G; IN_32] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_30] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[30].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_31] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_31: usize = 2;
-const IN_31: usize = 2;
-const OUT_31: usize = 2;
-fn aiur_fn_31(
-  inp: [G; IN_31],
+const INPUT_SIZE_32: usize = 2;
+const IN_32: usize = 2;
+const OUT_32: usize = 2;
+fn aiur_fn_32(
+  inp: [G; IN_32],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_31], 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];
@@ -1350,61 +1369,61 @@ fn aiur_fn_31(
         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_31] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_32] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { 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_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
         let __v_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_31] = { let __args: [G; IN_31] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { 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_32] = { let __args: [G; IN_32] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_31] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_32] = [__v_9, __v_7];
+        if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_32: usize = 1;
-const IN_32: usize = 1;
-const OUT_32: usize = 2;
-fn aiur_fn_32(
-  inp: [G; IN_32],
+const INPUT_SIZE_33: usize = 1;
+const IN_33: usize = 1;
+const OUT_33: usize = 2;
+fn aiur_fn_33(
+  inp: [G; IN_33],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_32], ExecError> {
+) -> Result<[G; OUT_33], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_34] = { let __args: [G; IN_34] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_32] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_33] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_33: usize = 2;
-const IN_33: usize = 2;
-const OUT_33: usize = 2;
-fn aiur_fn_33(
-  inp: [G; IN_33],
+const INPUT_SIZE_34: usize = 2;
+const IN_34: usize = 2;
+const OUT_34: usize = 2;
+fn aiur_fn_34(
+  inp: [G; IN_34],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_33], 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];
@@ -1413,12 +1432,12 @@ fn aiur_fn_33(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_33] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -1430,51 +1449,51 @@ fn aiur_fn_33(
         let __v_10: G = __r_arr[8];
         let __v_11: G = G::from_u64(1);
         let __v_12: G = (__v_1 - __v_11);
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { 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_34] = { let __args: [G; IN_34] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
         let __v_15: G = G::from_u64(0);
         let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_33] = [__v_16, __v_14];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_16, __v_14];
+        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_34: usize = 1;
-const IN_34: usize = 1;
-const OUT_34: usize = 2;
-fn aiur_fn_34(
-  inp: [G; IN_34],
+const INPUT_SIZE_35: usize = 1;
+const IN_35: usize = 1;
+const OUT_35: usize = 2;
+fn aiur_fn_35(
+  inp: [G; IN_35],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_34], ExecError> {
+) -> Result<[G; OUT_35], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_36] = { let __args: [G; IN_36] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_34] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_35] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_35: usize = 2;
-const IN_35: usize = 2;
-const OUT_35: usize = 2;
-fn aiur_fn_35(
-  inp: [G; IN_35],
+const INPUT_SIZE_36: usize = 2;
+const IN_36: usize = 2;
+const OUT_36: usize = 2;
+fn aiur_fn_36(
+  inp: [G; IN_36],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_35], 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];
@@ -1483,12 +1502,12 @@ fn aiur_fn_35(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_35] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_36] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -1498,7 +1517,7 @@ fn aiur_fn_35(
         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_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_10]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -1552,51 +1571,51 @@ fn aiur_fn_35(
         let __v_61: G = (__v_11 + __v_60);
         let __v_62: G = G::from_u64(1);
         let __v_63: G = (__v_1 - __v_62);
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_19, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_36] = { let __args: [G; IN_36] = [__v_19, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_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; 4] = [__v_66, __v_40, __v_61, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_35] = [__v_67, __v_65];
-        if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_36] = [__v_67, __v_65];
+        if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_36: usize = 1;
-const IN_36: usize = 1;
-const OUT_36: usize = 2;
-fn aiur_fn_36(
-  inp: [G; IN_36],
+const INPUT_SIZE_37: usize = 1;
+const IN_37: usize = 1;
+const OUT_37: usize = 2;
+fn aiur_fn_37(
+  inp: [G; IN_37],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_36], ExecError> {
+) -> Result<[G; OUT_37], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_38] = { let __args: [G; IN_38] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_36] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_37] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_37: usize = 2;
-const IN_37: usize = 2;
-const OUT_37: usize = 2;
-fn aiur_fn_37(
-  inp: [G; IN_37],
+const INPUT_SIZE_38: usize = 2;
+const IN_38: usize = 2;
+const OUT_38: usize = 2;
+fn aiur_fn_38(
+  inp: [G; IN_38],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_37], 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];
@@ -1605,12 +1624,12 @@ fn aiur_fn_37(
         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_37] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_38] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -1620,7 +1639,7 @@ fn aiur_fn_37(
         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_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_10]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -1630,7 +1649,7 @@ fn aiur_fn_37(
         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_26] = { let __args: [G; IN_26] = [__v_19]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_19]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -1640,7 +1659,7 @@ fn aiur_fn_37(
         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_26] = { let __args: [G; IN_26] = [__v_28]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_27] = { let __args: [G; IN_27] = [__v_28]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_29: G = __r_arr[0];
         let __v_30: G = __r_arr[1];
         let __v_31: G = __r_arr[2];
@@ -1652,52 +1671,52 @@ fn aiur_fn_37(
         let __v_37: G = __r_arr[8];
         let __v_38: G = G::from_u64(1);
         let __v_39: G = (__v_1 - __v_38);
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_38] = { let __args: [G; IN_38] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { 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 __v_41: G = __r_arr[1];
         let __v_42: G = G::from_u64(0);
         let __v_43: G = { let __values: [G; 32] = [__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, __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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_37] = [__v_44, __v_41];
-        if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_38] = [__v_44, __v_41];
+        if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_38: usize = 1;
-const IN_38: usize = 1;
-const OUT_38: usize = 2;
-fn aiur_fn_38(
-  inp: [G; IN_38],
+const INPUT_SIZE_39: usize = 1;
+const IN_39: usize = 1;
+const OUT_39: usize = 2;
+fn aiur_fn_39(
+  inp: [G; IN_39],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_38], ExecError> {
+) -> Result<[G; OUT_39], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { 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_40] = { let __args: [G; IN_40] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_38] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_39] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_39: usize = 2;
-const IN_39: usize = 2;
-const OUT_39: usize = 2;
-fn aiur_fn_39(
-  inp: [G; IN_39],
+const INPUT_SIZE_40: usize = 2;
+const IN_40: usize = 2;
+const OUT_40: usize = 2;
+fn aiur_fn_40(
+  inp: [G; IN_40],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_39], 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];
@@ -1706,61 +1725,61 @@ fn aiur_fn_39(
         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_39] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_40] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
         let __v_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_39] = { let __args: [G; IN_39] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { 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_40] = { let __args: [G; IN_40] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_39] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_40] = [__v_9, __v_7];
+        if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_40: usize = 1;
-const IN_40: usize = 1;
-const OUT_40: usize = 2;
-fn aiur_fn_40(
-  inp: [G; IN_40],
+const INPUT_SIZE_41: usize = 1;
+const IN_41: usize = 1;
+const OUT_41: usize = 2;
+fn aiur_fn_41(
+  inp: [G; IN_41],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_40], ExecError> {
+) -> Result<[G; OUT_41], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { 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_42] = { let __args: [G; IN_42] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_40] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_41] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_41: usize = 2;
-const IN_41: usize = 2;
-const OUT_41: usize = 2;
-fn aiur_fn_41(
-  inp: [G; IN_41],
+const INPUT_SIZE_42: usize = 2;
+const IN_42: usize = 2;
+const OUT_42: usize = 2;
+fn aiur_fn_42(
+  inp: [G; IN_42],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_41], 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];
@@ -1769,61 +1788,64 @@ fn aiur_fn_41(
         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_41] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_42] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_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_41] = { let __args: [G; IN_41] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_41] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { 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_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_1 - __v_6);
+        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { 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_8: G = __r_arr[0];
+        let __v_9: G = __r_arr[1];
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __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_42] = [__v_11, __v_9];
+        if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_42: usize = 1;
-const IN_42: usize = 1;
-const OUT_42: usize = 2;
-fn aiur_fn_42(
-  inp: [G; IN_42],
+const INPUT_SIZE_43: usize = 1;
+const IN_43: usize = 1;
+const OUT_43: usize = 2;
+fn aiur_fn_43(
+  inp: [G; IN_43],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_42], ExecError> {
+) -> Result<[G; OUT_43], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { 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_44] = { let __args: [G; IN_44] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_42] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_43] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].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 = 2;
-fn aiur_fn_43(
-  inp: [G; IN_43],
+const INPUT_SIZE_44: usize = 2;
+const IN_44: usize = 2;
+const OUT_44: usize = 2;
+fn aiur_fn_44(
+  inp: [G; IN_44],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_43], 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];
@@ -1832,49 +1854,29 @@ fn aiur_fn_43(
         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_43] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_44] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_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_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { 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_44] = { let __args: [G; IN_44] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_43] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_44] = [__v_9, __v_7];
+        if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_44: usize = 1;
-const IN_44: usize = 1;
-const OUT_44: usize = 2;
-fn aiur_fn_44(
-  inp: [G; IN_44],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_44], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __ret: [G; OUT_44] = [__v_1, __v_2];
-    if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
 const INPUT_SIZE_45: usize = 1;
 const IN_45: usize = 1;
 const OUT_45: usize = 2;
@@ -1886,7 +1888,7 @@ fn aiur_fn_45(
 ) -> Result<[G; OUT_45], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { 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)? } };
@@ -1920,7 +1922,7 @@ fn aiur_fn_46(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_43] = { let __args: [G; IN_43] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = G::from_u64(1);
@@ -1940,7 +1942,7 @@ fn aiur_fn_46(
 
 const INPUT_SIZE_47: usize = 1;
 const IN_47: usize = 1;
-const OUT_47: usize = 4;
+const OUT_47: usize = 2;
 fn aiur_fn_47(
   inp: [G; IN_47],
   record: &mut QueryRecord,
@@ -1949,16 +1951,10 @@ fn aiur_fn_47(
 ) -> Result<[G; OUT_47], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_47] = [__v_1, __v_3, __v_5, __v_6];
+    let __ret: [G; OUT_47] = [__v_1, __v_2];
     if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
@@ -1966,7 +1962,7 @@ fn aiur_fn_47(
 
 const INPUT_SIZE_48: usize = 1;
 const IN_48: usize = 1;
-const OUT_48: usize = 3;
+const OUT_48: usize = 2;
 fn aiur_fn_48(
   inp: [G; IN_48],
   record: &mut QueryRecord,
@@ -1975,23 +1971,20 @@ fn aiur_fn_48(
 ) -> Result<[G; OUT_48], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { 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_49] = { let __args: [G; IN_49] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_48] = [__v_3, __v_5, __v_6];
+    let __ret: [G; OUT_48] = [__v_3, __v_4];
     if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_49: usize = 1;
-const IN_49: usize = 1;
+const INPUT_SIZE_49: usize = 2;
+const IN_49: usize = 2;
 const OUT_49: usize = 2;
 fn aiur_fn_49(
   inp: [G; IN_49],
@@ -1999,29 +1992,6 @@ fn aiur_fn_49(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_49], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_49] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_50: usize = 2;
-const IN_50: usize = 2;
-const OUT_50: usize = 2;
-fn aiur_fn_50(
-  inp: [G; IN_50],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_50], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2029,39 +1999,59 @@ fn aiur_fn_50(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_50] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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_49] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { 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_4: G = __r_arr[0];
-        let __v_5: G = __r_arr[1];
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = (__v_1 - __v_8);
-        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = __r_arr[1];
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_50] = [__v_13, __v_11];
-        if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_49] = [__v_9, __v_7];
+        if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
+const INPUT_SIZE_50: usize = 1;
+const IN_50: usize = 1;
+const OUT_50: usize = 4;
+fn aiur_fn_50(
+  inp: [G; IN_50],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_50], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_50] = [__v_1, __v_3, __v_5, __v_6];
+    if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    return Ok(__ret);
+  })
+}
+
 const INPUT_SIZE_51: usize = 1;
 const IN_51: usize = 1;
-const OUT_51: usize = 4;
+const OUT_51: usize = 3;
 fn aiur_fn_51(
   inp: [G; IN_51],
   record: &mut QueryRecord,
@@ -2070,16 +2060,16 @@ fn aiur_fn_51(
 ) -> Result<[G; OUT_51], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { 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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_42] = { let __args: [G; IN_42] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_51] = [__v_1, __v_3, __v_5, __v_6];
+    let __ret: [G; OUT_51] = [__v_3, __v_5, __v_6];
     if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
@@ -2096,7 +2086,7 @@ fn aiur_fn_52(
 ) -> Result<[G; OUT_52], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { 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)? } };
@@ -2124,19 +2114,19 @@ fn aiur_fn_53(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; 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_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_53] = [__v_4, __v_0];
         if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { 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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_42] = { let __args: [G; IN_42] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { 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_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __v_8: G = G::from_u64(1);
@@ -2145,7 +2135,7 @@ fn aiur_fn_53(
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 5] = [__v_12, __v_2, __v_4, __v_6, __v_10]; 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_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_53] = [__v_13, __v_11];
         if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
@@ -2156,7 +2146,7 @@ fn aiur_fn_53(
 
 const INPUT_SIZE_54: usize = 1;
 const IN_54: usize = 1;
-const OUT_54: usize = 3;
+const OUT_54: usize = 4;
 fn aiur_fn_54(
   inp: [G; IN_54],
   record: &mut QueryRecord,
@@ -2165,19 +2155,19 @@ fn aiur_fn_54(
 ) -> Result<[G; OUT_54], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { 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_28] = { let __args: [G; IN_28] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __ret: [G; OUT_54] = [__v_3, __v_7, __v_8];
+    let __ret: [G; OUT_54] = [__v_1, __v_5, __v_7, __v_8];
     if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
@@ -2194,7 +2184,7 @@ fn aiur_fn_55(
 ) -> Result<[G; OUT_55], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { 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)? } };
@@ -2222,22 +2212,22 @@ fn aiur_fn_56(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; 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_56] = [__v_4, __v_0];
         if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
-        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { 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_28] = { let __args: [G; IN_28] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_7, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         let __v_10: G = G::from_u64(1);
@@ -2246,7 +2236,7 @@ fn aiur_fn_56(
         let __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 4] = [__v_14, __v_4, __v_8, __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_15: G = { let __values: [G; 5] = [__v_14, __v_2, __v_6, __v_8, __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_56] = [__v_15, __v_13];
         if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
@@ -2257,7 +2247,7 @@ fn aiur_fn_56(
 
 const INPUT_SIZE_57: usize = 1;
 const IN_57: usize = 1;
-const OUT_57: usize = 13;
+const OUT_57: usize = 14;
 fn aiur_fn_57(
   inp: [G; IN_57],
   record: &mut QueryRecord,
@@ -2266,35 +2256,41 @@ fn aiur_fn_57(
 ) -> Result<[G; OUT_57], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { 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_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { 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_53] = { let __args: [G; IN_53] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_28] = { let __args: [G; IN_28] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_12]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_56] = { let __args: [G; IN_56] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
-    let __v_15: G = __r_arr[2];
-    let __v_16: G = __r_arr[3];
-    let __v_17: G = __r_arr[4];
-    let __v_18: G = __r_arr[5];
-    let __v_19: G = __r_arr[6];
-    let __v_20: G = __r_arr[7];
-    let __v_21: G = __r_arr[8];
-    let __ret: [G; OUT_57] = [__v_3, __v_5, __v_9, __v_11, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_15: G = __r_arr[0];
+    let __v_16: G = __r_arr[1];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_17: G = __r_arr[0];
+    let __v_18: G = __r_arr[1];
+    let __v_19: G = __r_arr[2];
+    let __v_20: G = __r_arr[3];
+    let __v_21: G = __r_arr[4];
+    let __v_22: G = __r_arr[5];
+    let __v_23: G = __r_arr[6];
+    let __v_24: G = __r_arr[7];
+    let __v_25: G = __r_arr[8];
+    let __ret: [G; OUT_57] = [__v_3, __v_5, __v_9, __v_13, __v_15, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
     if let Some(result) = record.function_queries[57].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
@@ -2311,7 +2307,7 @@ fn aiur_fn_58(
 ) -> Result<[G; OUT_58], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { 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_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     match __v_1.as_canonical_u64() {
@@ -2323,7 +2319,7 @@ fn aiur_fn_58(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { 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_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = G::from_u64(1);
@@ -2337,7 +2333,7 @@ fn aiur_fn_58(
 
 const INPUT_SIZE_59: usize = 1;
 const IN_59: usize = 1;
-const OUT_59: usize = 24;
+const OUT_59: usize = 25;
 fn aiur_fn_59(
   inp: [G; IN_59],
   record: &mut QueryRecord,
@@ -2346,72 +2342,78 @@ fn aiur_fn_59(
 ) -> Result<[G; OUT_59], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { 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_32] = { let __args: [G; IN_32] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_14, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { 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_32] = { let __args: [G; IN_32] = [__v_14, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_17: G = __r_arr[0];
     let __v_18: G = __r_arr[1];
-    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_18, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { 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_18, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { 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_19: G = __r_arr[0];
     let __v_20: G = __r_arr[1];
-    let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
     let __v_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_23: G = __r_arr[0];
     let __v_24: G = __r_arr[1];
-    let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_24, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { 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_53] = { let __args: [G; IN_53] = [__v_24, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { 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_25: G = __r_arr[0];
     let __v_26: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_28] = { let __args: [G; IN_28] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_27: G = __r_arr[0];
     let __v_28: G = __r_arr[1];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_28]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_56] = { let __args: [G; IN_56] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { 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_29: G = __r_arr[0];
     let __v_30: G = __r_arr[1];
-    let __v_31: G = __r_arr[2];
-    let __v_32: G = __r_arr[3];
-    let __v_33: G = __r_arr[4];
-    let __v_34: G = __r_arr[5];
-    let __v_35: G = __r_arr[6];
-    let __v_36: G = __r_arr[7];
-    let __v_37: G = __r_arr[8];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { 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_38: G = __r_arr[0];
-    let __v_39: G = __r_arr[1];
-    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { 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_40: G = __r_arr[0];
-    let __v_41: G = __r_arr[1];
-    let __v_42: G = __r_arr[2];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { 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_43: G = __r_arr[0];
-    let __v_44: G = __r_arr[1];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { 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_45: G = __r_arr[0];
-    let __v_46: G = __r_arr[1];
-    let __ret: [G; OUT_59] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_40, __v_41, __v_43, __v_45, __v_46];
+    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_31: G = __r_arr[0];
+    let __v_32: G = __r_arr[1];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_32]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_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 __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { 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_42: G = __r_arr[0];
+    let __v_43: G = __r_arr[1];
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { 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_44: G = __r_arr[0];
+    let __v_45: G = __r_arr[1];
+    let __v_46: G = __r_arr[2];
+    let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { 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_47: G = __r_arr[0];
+    let __v_48: G = __r_arr[1];
+    let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
+    let __v_49: G = __r_arr[0];
+    let __v_50: G = __r_arr[1];
+    let __ret: [G; OUT_59] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_29, __v_31, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_42, __v_44, __v_45, __v_47, __v_49, __v_50];
     if let Some(result) = record.function_queries[59].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
@@ -4394,7 +4396,7 @@ fn aiur_fn_68(
         let __v_14: G = __loaded[5];
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__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[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_17: G = __r_arr[0];
         let __v_18: G = (__v_17 * __v_8);
         let __v_19: G = (__v_2 - __v_1);
@@ -4665,7 +4667,7 @@ fn aiur_fn_69(
     let __v_72: G = __r_arr[63];
     match __v_2.as_canonical_u64() {
       1023u64 => {
-        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -4676,7 +4678,7 @@ fn aiur_fn_69(
         let __v_79: G = __loaded[5];
         let __v_80: G = __loaded[6];
         let __v_81: G = __loaded[7];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_82: G = __r_arr[0];
         let __v_83: G = (__v_73 * __v_82);
         let __v_84: G = (__v_8 * __v_83);
@@ -4828,7 +4830,7 @@ fn aiur_fn_69(
         let __v_226: G = __loaded[5];
         let __v_227: G = __loaded[6];
         let __v_228: G = __loaded[7];
-        let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_9(__args, record, io_buffer, false)? } else { 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_10] = { let __args: [G; IN_10] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_10(__args, record, io_buffer, false)? } else { 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_229: G = __r_arr[0];
         let __v_230: G = __r_arr[1];
         let __v_231: G = __r_arr[2];
@@ -4846,10 +4848,10 @@ fn aiur_fn_69(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } };
         let __v_73: G = __r_arr[0];
         let __v_74: G = (__v_73 * __v_7);
-        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -4860,7 +4862,7 @@ fn aiur_fn_69(
         let __v_81: G = __loaded[5];
         let __v_82: G = __loaded[6];
         let __v_83: G = __loaded[7];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_84: G = __r_arr[0];
         let __v_85: G = (__v_84 * __v_8);
         let __v_86: G = (__v_75 * __v_85);
@@ -9156,7 +9158,7 @@ fn aiur_fn_94(
     let __v_105: G = __r_arr[1];
     let __v_106: G = G::from_u64(0);
     let __v_107: G = { let __values: [G; 10] = [__v_106, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_99]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_87, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_87, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } };
     let __v_108: G = __r_arr[0];
     let __ret: [G; OUT_94] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_108, __v_98, __v_101, __v_102, __v_104, __v_105];
     if let Some(result) = record.function_queries[94].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
@@ -9658,15 +9660,102 @@ fn aiur_fn_101(
   })
 }
 
-const INPUT_SIZE_102: usize = 2;
-const IN_102: usize = 2;
-const OUT_102: usize = 11;
+const INPUT_SIZE_102: usize = 3;
+const IN_102: usize = 3;
+const OUT_102: usize = 1;
 fn aiur_fn_102(
   inp: [G; IN_102],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_102], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_102] = [__v_8];
+        if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        match __v_6.as_canonical_u64() {
+          0u64 => {
+            let __v_9: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+            match __v_9.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { 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_10: G = __r_arr[0];
+                let __ret: [G; OUT_102] = [__v_10];
+                if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+              _ => {
+                let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; 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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+                let __v_10: G = __loaded[0];
+                let __v_11: G = __loaded[1];
+                let __v_12: G = __loaded[2];
+                let __v_13: G = __loaded[3];
+                let __v_14: G = __loaded[4];
+                let __v_15: G = __loaded[5];
+                let __v_16: G = __loaded[6];
+                let __v_17: G = __loaded[7];
+                let __v_18: G = __loaded[8];
+                let __v_19: G = __loaded[9];
+                match __v_10.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { 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_20: G = __r_arr[0];
+                    let __ret: [G; OUT_102] = [__v_20];
+                    if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_20: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { 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_21: G = __r_arr[0];
+                    let __v_22: G = { let __values: [G; 3] = [__v_20, __v_4, __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_102] = [__v_22];
+                    if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_103: usize = 2;
+const IN_103: usize = 2;
+const OUT_103: usize = 11;
+fn aiur_fn_103(
+  inp: [G; IN_103],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_103], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9761,8 +9850,8 @@ fn aiur_fn_102(
           return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
         }
         let __v_78: G = G::from_u64(1);
-        let __ret: [G; OUT_102] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_78];
-        if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_103] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_78];
+        if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
@@ -9781,12 +9870,12 @@ fn aiur_fn_102(
             let __v_21: G = G::from_u64(0);
             let __v_22: G = G::from_u64(0);
             let __v_23: G = G::from_u64(0);
-            let __ret: [G; OUT_102] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_0, __v_1, __v_23];
-            if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_103] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_0, __v_1, __v_23];
+            if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { 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_15: G = __r_arr[0];
             let __v_16: G = __r_arr[1];
             let __v_17: G = __r_arr[2];
@@ -9798,8 +9887,8 @@ fn aiur_fn_102(
             let __v_23: G = __r_arr[8];
             let __v_24: G = __r_arr[9];
             let __v_25: G = __r_arr[10];
-            let __ret: [G; OUT_102] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-            if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_103] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+            if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -9814,15 +9903,15 @@ fn aiur_fn_102(
   })
 }
 
-const INPUT_SIZE_103: usize = 6;
-const IN_103: usize = 6;
-const OUT_103: usize = 1;
-fn aiur_fn_103(
-  inp: [G; IN_103],
+const INPUT_SIZE_104: usize = 6;
+const IN_104: usize = 6;
+const OUT_104: usize = 1;
+fn aiur_fn_104(
+  inp: [G; IN_104],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_103], ExecError> {
+) -> Result<[G; OUT_104], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9830,7 +9919,7 @@ fn aiur_fn_103(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     let __v_8: G = __r_arr[2];
@@ -10035,68 +10124,68 @@ fn aiur_fn_103(
                                         let __v_185: G = __r_arr[30];
                                         let __v_186: G = __r_arr[31];
                                         let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __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]; 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_103] = [__v_187];
-                                        if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        let __ret: [G; OUT_104] = [__v_187];
+                                        if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __ret: [G; OUT_103] = [__v_5];
-                                        if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        let __ret: [G; OUT_104] = [__v_5];
+                                        if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                         return Ok(__ret);
                                       },
                                     }
                                   },
                                   _ => {
-                                    let __ret: [G; OUT_103] = [__v_5];
-                                    if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_104] = [__v_5];
+                                    if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
-                                let __ret: [G; OUT_103] = [__v_5];
-                                if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_104] = [__v_5];
+                                if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
-                            let __ret: [G; OUT_103] = [__v_5];
-                            if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_104] = [__v_5];
+                            if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
-                        let __ret: [G; OUT_103] = [__v_5];
-                        if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_104] = [__v_5];
+                        if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __ret: [G; OUT_103] = [__v_5];
-                    if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_104] = [__v_5];
+                    if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_103] = [__v_5];
-                if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_104] = [__v_5];
+                if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_103] = [__v_5];
-            if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_104] = [__v_5];
+            if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { 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_17: G = __r_arr[0];
         let __v_18: G = __r_arr[1];
         let __v_19: G = __r_arr[2];
@@ -10108,7 +10197,7 @@ fn aiur_fn_103(
         let __v_25: G = __r_arr[8];
         let __v_26: G = __r_arr[9];
         let __v_27: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -10120,7 +10209,7 @@ fn aiur_fn_103(
         let __v_36: G = __r_arr[8];
         let __v_37: G = __r_arr[9];
         let __v_38: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { 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_39: G = __r_arr[0];
         let __v_40: G = __r_arr[1];
         let __v_41: G = __r_arr[2];
@@ -10132,7 +10221,7 @@ fn aiur_fn_103(
         let __v_47: G = __r_arr[8];
         let __v_48: G = __r_arr[9];
         let __v_49: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { 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_50: G = __r_arr[0];
         let __v_51: G = __r_arr[1];
         let __v_52: G = __r_arr[2];
@@ -10144,7 +10233,7 @@ fn aiur_fn_103(
         let __v_58: G = __r_arr[8];
         let __v_59: G = __r_arr[9];
         let __v_60: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { 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_61: G = __r_arr[0];
         let __v_62: G = __r_arr[1];
         let __v_63: G = __r_arr[2];
@@ -10156,7 +10245,7 @@ fn aiur_fn_103(
         let __v_69: G = __r_arr[8];
         let __v_70: G = __r_arr[9];
         let __v_71: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_69, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_69, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { 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_72: G = __r_arr[0];
         let __v_73: G = __r_arr[1];
         let __v_74: G = __r_arr[2];
@@ -10168,7 +10257,7 @@ fn aiur_fn_103(
         let __v_80: G = __r_arr[8];
         let __v_81: G = __r_arr[9];
         let __v_82: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { 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_83: G = __r_arr[0];
         let __v_84: G = __r_arr[1];
         let __v_85: G = __r_arr[2];
@@ -10240,7 +10329,7 @@ fn aiur_fn_103(
         let __v_126: G = __loaded[5];
         let __v_127: G = __loaded[6];
         let __v_128: G = __loaded[7];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_129: G = __r_arr[0];
         let __v_130: G = (__v_113 * __v_129);
         let __v_131: G = G::from_u64(2);
@@ -10351,8 +10440,8 @@ fn aiur_fn_103(
           1u64 => {
             let __v_232: G = G::from_u64(0);
             let __v_233: G = { let __values: [G; 34] = [__v_232, __v_5, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; 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_103] = [__v_233];
-            if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_104] = [__v_233];
+            if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -10400,7 +10489,7 @@ fn aiur_fn_103(
                 let __v_270: G = __loaded[5];
                 let __v_271: G = __loaded[6];
                 let __v_272: G = __loaded[7];
-                let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_9(__args, record, io_buffer, false)? } else { 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_10] = { let __args: [G; IN_10] = [__v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_10(__args, record, io_buffer, false)? } else { 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_273: G = __r_arr[0];
                 let __v_274: G = __r_arr[1];
                 let __v_275: G = __r_arr[2];
@@ -10413,20 +10502,20 @@ fn aiur_fn_103(
                 let __v_282: G = { let __values: [G; 32] = [__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, __v_246, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_283: G = G::from_u64(0);
                 let __v_284: G = { let __values: [G; 34] = [__v_283, __v_5, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; 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_103] = { let __args: [G; IN_103] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { 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_285: G = __r_arr[0];
-                let __ret: [G; OUT_103] = [__v_285];
-                if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_104] = [__v_285];
+                if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_232: G = G::from_u64(1);
                 let __v_233: G = (__v_2 + __v_232);
                 let __v_234: G = { let __values: [G; 32] = [__v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { 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_235: G = __r_arr[0];
-                let __ret: [G; OUT_103] = [__v_235];
-                if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_104] = [__v_235];
+                if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -10437,15 +10526,15 @@ fn aiur_fn_103(
   })
 }
 
-const INPUT_SIZE_104: usize = 1;
-const IN_104: usize = 1;
-const OUT_104: usize = 32;
-fn aiur_fn_104(
-  inp: [G; IN_104],
+const INPUT_SIZE_105: usize = 1;
+const IN_105: usize = 1;
+const OUT_105: usize = 32;
+fn aiur_fn_105(
+  inp: [G; IN_105],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_104], ExecError> {
+) -> Result<[G; OUT_105], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(103);
@@ -10497,7 +10586,7 @@ fn aiur_fn_104(
     let __v_47: G = G::from_u64(1);
     let __v_48: G = G::from_u64(1);
     let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { 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_50: G = __r_arr[0];
     let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { 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_51: G = __r_arr[0];
@@ -10532,21 +10621,21 @@ fn aiur_fn_104(
     let __v_80: G = __r_arr[29];
     let __v_81: G = __r_arr[30];
     let __v_82: G = __r_arr[31];
-    let __ret: [G; OUT_104] = [__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];
-    if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_105] = [__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];
+    if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_105: usize = 3;
-const IN_105: usize = 3;
-const OUT_105: usize = 1;
-fn aiur_fn_105(
-  inp: [G; IN_105],
+const INPUT_SIZE_106: usize = 3;
+const IN_106: usize = 3;
+const OUT_106: usize = 1;
+fn aiur_fn_106(
+  inp: [G; IN_106],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_105], ExecError> {
+) -> Result<[G; OUT_106], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10602,7 +10691,7 @@ fn aiur_fn_105(
     let __v_50: G = G::from_u64(1);
     let __v_51: G = G::from_u64(1);
     let __v_52: G = { let __values: [G; 34] = [__v_50, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51]; 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_103] = { let __args: [G; IN_103] = [__v_38, __v_3, __v_39, __v_48, __v_49, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_38, __v_3, __v_39, __v_48, __v_49, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { 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_53: G = __r_arr[0];
     let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { 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_54: G = __r_arr[0];
@@ -10638,21 +10727,21 @@ fn aiur_fn_105(
     let __v_84: G = __r_arr[30];
     let __v_85: G = __r_arr[31];
     let __v_86: G = { let __values: [G; 32] = [__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 __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_105] = [__v_86];
-    if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_106] = [__v_86];
+    if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_106: usize = 4;
-const IN_106: usize = 4;
-const OUT_106: usize = 1;
-fn aiur_fn_106(
-  inp: [G; IN_106],
+const INPUT_SIZE_107: usize = 4;
+const IN_107: usize = 4;
+const OUT_107: usize = 1;
+fn aiur_fn_107(
+  inp: [G; IN_107],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_106], ExecError> {
+) -> Result<[G; OUT_107], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10662,32 +10751,32 @@ fn aiur_fn_106(
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_106] = [__v_3];
-        if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_107] = [__v_3];
+        if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
         let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_106] = [__v_6];
-        if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_107] = [__v_6];
+        if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_107: usize = 1;
-const IN_107: usize = 1;
-const OUT_107: usize = 1;
-fn aiur_fn_107(
-  inp: [G; IN_107],
+const INPUT_SIZE_108: usize = 1;
+const IN_108: usize = 1;
+const OUT_108: usize = 1;
+fn aiur_fn_108(
+  inp: [G; IN_108],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_107], ExecError> {
+) -> Result<[G; OUT_108], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __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 };
@@ -10697,18 +10786,18 @@ fn aiur_fn_107(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_107] = [__v_4];
-        if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_108] = [__v_4];
+        if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         let __v_4: G = G::from_u64(2);
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = (__v_4 * __v_5);
         let __v_7: G = (__v_2 + __v_6);
-        let __ret: [G; OUT_107] = [__v_7];
-        if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_108] = [__v_7];
+        if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -10718,123 +10807,113 @@ fn aiur_fn_107(
   })
 }
 
-const INPUT_SIZE_108: usize = 6;
-const IN_108: usize = 6;
-const OUT_108: usize = 2;
-fn aiur_fn_108(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_108], ExecError> {
+) -> Result<[G; OUT_109], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_6: G = __loaded[0];
-    let __v_7: G = __loaded[1];
-    let __v_8: G = __loaded[2];
-    match __v_6.as_canonical_u64() {
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    match __v_2.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_108] = [__v_0, __v_9];
-        if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_109] = [__v_1];
+        if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        match __v_9.as_canonical_u64() {
-          0u64 => {
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() {
-  0u64 => {
-    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { 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_12: G = __r_arr[0];
-    break '__mc_0 [__v_12];
-  },
-  _ => {
-    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_7, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { 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_12: G = __r_arr[0];
-    break '__mc_0 [__v_12];
-  },
-}
- };
-            let __v_12: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0];
-            let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_13.as_canonical_u64() {
-  0u64 => {
-    break '__mc_1 [__v_12];
-  },
-  _ => {
-    let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { 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_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { 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_15: G = __r_arr[0];
-    break '__mc_1 [__v_15];
-  },
-}
- };
-            let __v_14: G = __mc_out___mc_1[0];
-            let __v_15: G = G::from_u64(1);
-            let __v_16: G = (__v_5 - __v_15);
-            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_14, __v_1, __v_2, __v_8, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { 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_17: G = __r_arr[0];
-            let __v_18: G = __r_arr[1];
-            let __ret: [G; OUT_108] = [__v_17, __v_18];
-            if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_8: G = __loaded[0];
+        let __v_9: G = __loaded[1];
+        let __v_10: G = __loaded[2];
+        let __v_11: G = __loaded[3];
+        let __v_12: G = __loaded[4];
+        let __v_13: G = __loaded[5];
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_109] = [__v_0];
+            if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
+          0u64 => {
+            match __v_3.as_canonical_u64() {
+              _ => {
+                match __v_9.as_canonical_u64() {
+                  _ => {
+                    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
+                    let __v_14: G = __r_arr[0];
+                    match __v_14.as_canonical_u64() {
+                      1u64 => {
+                        let __v_15: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { 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_16: G = __r_arr[0];
+                        let __v_17: G = { let __values: [G; 6] = [__v_15, __v_3, __v_4, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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];
+                        if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_15: G = (__v_3 - __v_9);
+                        let __v_16: G = G::from_bool((__v_15 == G::ZERO));
+                        match __v_16.as_canonical_u64() {
+                          1u64 => {
+                            if (__v_6 != __v_12) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None });
+                            }
+                            if (__v_5 != __v_11) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None });
+                            }
+                            let __v_17: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_7, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { 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_18: G = __r_arr[0];
+                            let __v_19: G = { let __values: [G; 6] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __ret: [G; OUT_109] = [__v_19];
+                            if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __v_17: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { 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_18: G = __r_arr[0];
+                            let __v_19: G = { let __values: [G; 6] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __ret: [G; OUT_109] = [__v_19];
+                            if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_109: usize = 5;
-const IN_109: usize = 5;
-const OUT_109: usize = 2;
-fn aiur_fn_109(
-  inp: [G; IN_109],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_109], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __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_105] = { let __args: [G; IN_105] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
-    let __v_6: G = G::from_u64(1);
-    let __v_7: G = (__v_4 - __v_6);
-    let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_5, __v_0, __v_1, __v_3, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __v_9: G = __r_arr[1];
-    let __ret: [G; OUT_109] = [__v_8, __v_9];
-    if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_110: usize = 6;
-const IN_110: usize = 6;
-const OUT_110: usize = 1;
+const INPUT_SIZE_110: usize = 1;
+const IN_110: usize = 1;
+const OUT_110: usize = 2;
 fn aiur_fn_110(
   inp: [G; IN_110],
   record: &mut QueryRecord,
@@ -10843,30 +10922,73 @@ fn aiur_fn_110(
 ) -> Result<[G; OUT_110], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = G::from_u64(1);
-    let __v_8: G = (__v_5 - __v_7);
-    let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_6, __v_1, __v_2, __v_4, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { 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_9: G = __r_arr[0];
-    let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = (__v_11 - __v_9);
-    let __v_13: G = G::from_bool((__v_12 == G::ZERO));
-    let __ret: [G; OUT_110] = [__v_13];
-    if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 6] = [__v_7, __v_8, __v_8, __v_8, __v_8, __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_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_110] = [__v_9, __v_12];
+        if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        let __v_11: G = __loaded[4];
+        let __v_12: G = __loaded[5];
+        match __v_7.as_canonical_u64() {
+          1u64 => {
+            let __v_13: G = G::from_u64(0);
+            let __v_14: G = G::from_u64(1);
+            let __v_15: G = G::from_u64(1);
+            let __v_16: G = { let __values: [G; 6] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_13, __v_2, __v_3, __v_4, __v_5, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_18: G = G::from_u64(1);
+            let __v_19: G = G::from_u64(1);
+            let __v_20: G = { let __values: [G; 6] = [__v_18, __v_19, __v_19, __v_19, __v_19, __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_110] = [__v_17, __v_20];
+            if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            let __v_15: G = G::from_u64(0);
+            let __v_16: G = { let __values: [G; 6] = [__v_15, __v_2, __v_3, __v_4, __v_5, __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_17: G = G::from_u64(0);
+            let __v_18: G = { let __values: [G; 6] = [__v_17, __v_8, __v_9, __v_10, __v_11, __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_110] = [__v_16, __v_18];
+            if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_111: usize = 2;
-const IN_111: usize = 2;
+const INPUT_SIZE_111: usize = 1;
+const IN_111: usize = 1;
 const OUT_111: usize = 1;
 fn aiur_fn_111(
   inp: [G; IN_111],
@@ -10876,35 +10998,61 @@ fn aiur_fn_111(
 ) -> Result<[G; OUT_111], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_111] = [__v_1];
+        let __ret: [G; OUT_111] = [__v_0];
         if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         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_111] = { let __args: [G; IN_111] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_111] = [__v_7];
-        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        let __v_11: G = __loaded[4];
+        let __v_12: G = __loaded[5];
+        match __v_7.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_111] = [__v_0];
+            if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { 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_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+            let __v_15: G = __r_arr[0];
+            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+            let __v_16: G = __r_arr[0];
+            let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { 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_17: G = __r_arr[0];
+            let __ret: [G; OUT_111] = [__v_17];
+            if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+          },
+        }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_112: usize = 2;
-const IN_112: usize = 2;
+const INPUT_SIZE_112: usize = 4;
+const IN_112: usize = 4;
 const OUT_112: usize = 1;
 fn aiur_fn_112(
   inp: [G; IN_112],
@@ -10915,44 +11063,60 @@ fn aiur_fn_112(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    match __v_4.as_canonical_u64() {
       1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_112] = [__v_5];
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = G::from_u64(0);
+        if (__v_7 != __v_8) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
+        }
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = { let __values: [G; 6] = [__v_9, __v_10, __v_10, __v_10, __v_10, __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_112] = [__v_11];
         if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __v_5: G = (__v_0 * __v_0);
-        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        match __v_3.as_canonical_u64() {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        match __v_7.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_112] = [__v_6];
+            let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { 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 = G::from_u64(0);
+            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { 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_12: G = __r_arr[0];
+            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __v_14: G = { let __values: [G; 6] = [__v_11, __v_12, __v_5, __v_8, __v_10, __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_112] = [__v_14];
             if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __v_7: G = (__v_0 * __v_6);
-            let __ret: [G; OUT_112] = [__v_7];
-            if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_113: usize = 8;
-const IN_113: usize = 8;
+const INPUT_SIZE_113: usize = 4;
+const IN_113: usize = 4;
 const OUT_113: usize = 2;
 fn aiur_fn_113(
   inp: [G; IN_113],
@@ -10960,6 +11124,366 @@ fn aiur_fn_113(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_113], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    let __v_7: G = __loaded[3];
+    let __v_8: G = __loaded[4];
+    let __v_9: G = __loaded[5];
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = { let __values: [G; 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 __ret: [G; OUT_113] = [__v_12, __v_1];
+        if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_5.as_canonical_u64() {
+          _ => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_10: G = __loaded[0];
+            let __v_11: G = __loaded[1];
+            let __v_12: G = __loaded[2];
+            match __v_10.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { 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_13: 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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                let __v_14: G = __loaded[0];
+                let __v_15: G = __loaded[1];
+                let __v_16: G = __loaded[2];
+                let __v_17: G = __loaded[3];
+                let __v_18: G = __loaded[4];
+                let __v_19: G = __loaded[5];
+                match __v_14.as_canonical_u64() {
+                  0u64 => {
+                    match __v_15.as_canonical_u64() {
+                      _ => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; 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: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __v_20: G = __loaded[0];
+                        let __v_21: G = __loaded[1];
+                        let __v_22: G = __loaded[2];
+                        match __v_20.as_canonical_u64() {
+                          0u64 => {
+                            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { 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_23: G = __r_arr[0];
+                            let __v_24: G = (__v_13 - __v_23);
+                            let __v_25: G = G::from_bool((__v_24 == G::ZERO));
+                            match __v_25.as_canonical_u64() {
+                              1u64 => {
+                                let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { 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_26: G = __r_arr[0];
+                                let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_7, __v_2, __v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { 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_27: G = __r_arr[0];
+                                let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_19, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+                                let __v_28: G = __r_arr[0];
+                                let __v_29: G = __r_arr[1];
+                                let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_7, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { 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_30: G = __r_arr[0];
+                                let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_17, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { 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_31: G = __r_arr[0];
+                                if (__v_30 != __v_31) {
+                                  return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
+                                }
+                                let __v_32: G = G::from_u64(0);
+                                let __v_33: G = { let __values: [G; 6] = [__v_32, __v_13, __v_12, __v_7, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_33, __v_29];
+                                if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_26: G = __loaded[0];
+                                let __v_27: G = __loaded[1];
+                                let __v_28: G = __loaded[2];
+                                match __v_26.as_canonical_u64() {
+                                  0u64 => {
+                                    let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_11, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { 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_29: G = __r_arr[0];
+                                    let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_7, __v_2, __v_3, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { 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_30: G = __r_arr[0];
+                                    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9, __v_28, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { 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_31: G = __r_arr[0];
+                                    let __v_32: G = __r_arr[1];
+                                    let __v_33: G = G::from_u64(0);
+                                    let __v_34: G = { let __values: [G; 6] = [__v_33, __v_13, __v_12, __v_7, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_34, __v_32];
+                                    if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64()));
+                                  },
+                                }
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+                          },
+                        }
+                      },
+                    }
+                  },
+                  1u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_20: G = __loaded[0];
+                    let __v_21: G = __loaded[1];
+                    let __v_22: G = __loaded[2];
+                    match __v_20.as_canonical_u64() {
+                      0u64 => {
+                        let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_11, __v_8, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { 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_23: G = __r_arr[0];
+                        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_7, __v_2, __v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { 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_24: G = __r_arr[0];
+                        let __v_25: G = G::from_u64(0);
+                        let __v_26: G = G::from_u64(1);
+                        let __v_27: G = G::from_u64(1);
+                        let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_27, __v_27, __v_27, __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 __v_29: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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, __v_22];
+                        if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_114: usize = 4;
+const IN_114: usize = 4;
+const OUT_114: usize = 2;
+fn aiur_fn_114(
+  inp: [G; IN_114],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_114], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_114] = [__v_0, __v_1];
+        if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_3 - __v_4);
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_3 - __v_8);
+        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6, __v_7, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = __r_arr[1];
+        let __ret: [G; OUT_114] = [__v_10, __v_11];
+        if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_115: usize = 6;
+const IN_115: usize = 6;
+const OUT_115: usize = 1;
+fn aiur_fn_115(
+  inp: [G; IN_115],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_115], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_3, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7, __v_4, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __v_8: G = __r_arr[0];
+    let __v_9: 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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_10: G = __loaded[0];
+    let __v_11: G = __loaded[1];
+    let __v_12: G = __loaded[2];
+    let __v_13: G = __loaded[3];
+    let __v_14: G = __loaded[4];
+    let __v_15: G = __loaded[5];
+    match __v_10.as_canonical_u64() {
+      0u64 => {
+        match __v_11.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+            let __v_16: G = __r_arr[0];
+            let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+            let __v_17: G = __r_arr[0];
+            let __v_18: G = (__v_16 - __v_17);
+            let __v_19: G = G::from_bool((__v_18 == G::ZERO));
+            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(), msg: None });
+            }
+            let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+            let __v_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(), msg: None });
+            }
+            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+            let __v_23: G = __r_arr[0];
+            let __v_24: G = G::from_u64(0);
+            if (__v_23 != __v_24) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None });
+            }
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+            let __v_25: G = __r_arr[0];
+            let __v_26: G = (__v_25 - __v_14);
+            let __v_27: G = G::from_bool((__v_26 == G::ZERO));
+            let __ret: [G; OUT_115] = [__v_27];
+            if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_116: usize = 2;
+const IN_116: usize = 2;
+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_116], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_116] = [__v_1];
+        if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].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_116] = { let __args: [G; IN_116] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_7: G = __r_arr[0];
+        let __ret: [G; OUT_116] = [__v_7];
+        if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_117: usize = 2;
+const IN_117: usize = 2;
+const OUT_117: usize = 1;
+fn aiur_fn_117(
+  inp: [G; IN_117],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_117], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __ret: [G; OUT_117] = [__v_5];
+        if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = (__v_0 * __v_0);
+        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { 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_6: G = __r_arr[0];
+        match __v_3.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_117] = [__v_6];
+            if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_7: G = (__v_0 * __v_6);
+            let __ret: [G; OUT_117] = [__v_7];
+            if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_118: usize = 8;
+const IN_118: usize = 8;
+const OUT_118: usize = 2;
+fn aiur_fn_118(
+  inp: [G; IN_118],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_118], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10971,14 +11495,14 @@ fn aiur_fn_113(
     let __v_7: G = inp[7];
     let __v_8: G = G::from_u64(1);
     let __v_9: G = (__v_1 + __v_8);
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
     let __v_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_111] = { let __args: [G; IN_111] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { 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_15: G = __r_arr[0];
     let __v_16: G = (__v_15 + __v_15);
     let __v_17: G = (__v_4 + __v_6);
@@ -11060,50 +11584,50 @@ fn aiur_fn_113(
     let __v_81: G = (__v_79 + __v_80);
     let __v_82: G = (__v_42 + __v_78);
     let __v_83: G = (__v_45 + __v_81);
-    let __ret: [G; OUT_113] = [__v_82, __v_83];
-    if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_118] = [__v_82, __v_83];
+    if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_114: usize = 2;
-const IN_114: usize = 2;
-const OUT_114: usize = 1;
-fn aiur_fn_114(
-  inp: [G; IN_114],
+const INPUT_SIZE_119: usize = 2;
+const IN_119: usize = 2;
+const OUT_119: usize = 1;
+fn aiur_fn_119(
+  inp: [G; IN_119],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_114], 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];
     let __v_2: G = G::from_u64(7);
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(1);
     let __v_5: G = G::from_u64(1);
     let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { 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_8: G = __r_arr[0];
     let __v_9: G = (__v_2 * __v_8);
-    let __ret: [G; OUT_114] = [__v_9];
-    if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_119] = [__v_9];
+    if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_115: usize = 8;
-const IN_115: usize = 8;
-const OUT_115: usize = 4;
-fn aiur_fn_115(
-  inp: [G; IN_115],
+const INPUT_SIZE_120: usize = 8;
+const IN_120: usize = 8;
+const OUT_120: usize = 4;
+fn aiur_fn_120(
+  inp: [G; IN_120],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_115], 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];
@@ -11126,8 +11650,8 @@ fn aiur_fn_115(
     let __v_17: G = __loaded[9];
     match __v_8.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_115] = [__v_4, __v_5, __v_6, __v_7];
-        if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_120] = [__v_4, __v_5, __v_6, __v_7];
+        if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -11180,13 +11704,13 @@ fn aiur_fn_115(
             let __v_61: G = (__v_6 * __v_3);
             let __v_62: G = (__v_7 * __v_2);
             let __v_63: G = (__v_61 + __v_62);
-            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_60, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_120] = { let __args: [G; IN_120] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_60, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
             let __v_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 __ret: [G; OUT_115] = [__v_64, __v_65, __v_66, __v_67];
-            if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_120] = [__v_64, __v_65, __v_66, __v_67];
+            if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -11201,15 +11725,15 @@ fn aiur_fn_115(
   })
 }
 
-const INPUT_SIZE_116: usize = 2;
-const IN_116: usize = 2;
-const OUT_116: usize = 1;
-fn aiur_fn_116(
-  inp: [G; IN_116],
+const INPUT_SIZE_121: usize = 2;
+const IN_121: usize = 2;
+const OUT_121: usize = 1;
+fn aiur_fn_121(
+  inp: [G; IN_121],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_116], 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];
@@ -11220,8 +11744,8 @@ fn aiur_fn_116(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_116] = [__v_1];
-        if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_121] = [__v_1];
+        if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -11337,14 +11861,14 @@ fn aiur_fn_116(
         if (__v_94 != __v_95) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_95.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_121] = { let __args: [G; IN_121] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
         let __v_96: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
         let __v_97: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
         let __v_98: G = __r_arr[0];
-        let __ret: [G; OUT_116] = [__v_98];
-        if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_121] = [__v_98];
+        if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -11354,15 +11878,15 @@ fn aiur_fn_116(
   })
 }
 
-const INPUT_SIZE_117: usize = 2;
-const IN_117: usize = 2;
-const OUT_117: usize = 1;
-fn aiur_fn_117(
-  inp: [G; IN_117],
+const INPUT_SIZE_122: usize = 2;
+const IN_122: usize = 2;
+const OUT_122: usize = 1;
+fn aiur_fn_122(
+  inp: [G; IN_122],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_117], 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];
@@ -11372,17 +11896,17 @@ fn aiur_fn_117(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_117] = [__v_1];
-        if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_122] = [__v_1];
+        if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { 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_122] = { let __args: [G; IN_122] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_121] = { let __args: [G; IN_121] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_117] = [__v_6];
-        if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_122] = [__v_6];
+        if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -11392,15 +11916,15 @@ fn aiur_fn_117(
   })
 }
 
-const INPUT_SIZE_118: usize = 2;
-const IN_118: usize = 2;
-const OUT_118: usize = 1;
-fn aiur_fn_118(
-  inp: [G; IN_118],
+const INPUT_SIZE_123: usize = 2;
+const IN_123: usize = 2;
+const OUT_123: usize = 1;
+fn aiur_fn_123(
+  inp: [G; IN_123],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_118], 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];
@@ -11410,17 +11934,17 @@ fn aiur_fn_118(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_118] = [__v_1];
-        if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_123] = [__v_1];
+        if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { 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_122] = { let __args: [G; IN_122] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_118] = [__v_6];
-        if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_123] = [__v_6];
+        if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -11430,30 +11954,30 @@ fn aiur_fn_118(
   })
 }
 
-const INPUT_SIZE_119: usize = 3;
-const IN_119: usize = 3;
-const OUT_119: usize = 1;
-fn aiur_fn_119(
-  inp: [G; IN_119],
+const INPUT_SIZE_124: usize = 3;
+const IN_124: usize = 3;
+const OUT_124: usize = 1;
+fn aiur_fn_124(
+  inp: [G; IN_124],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_119], ExecError> {
+) -> Result<[G; OUT_124], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_119] = [__v_2];
-        if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_124] = [__v_2];
+        if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_3: G = __r_arr[0];
-        let __ret: [G; OUT_119] = [__v_3];
-        if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_124] = [__v_3];
+        if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -11463,15 +11987,15 @@ fn aiur_fn_119(
   })
 }
 
-const INPUT_SIZE_120: usize = 2;
-const IN_120: usize = 2;
-const OUT_120: usize = 1;
-fn aiur_fn_120(
-  inp: [G; IN_120],
+const INPUT_SIZE_125: usize = 2;
+const IN_125: usize = 2;
+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_120], ExecError> {
+) -> Result<[G; OUT_125], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11481,8 +12005,8 @@ fn aiur_fn_120(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_120] = [__v_0];
-        if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_125] = [__v_0];
+        if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -11494,12 +12018,12 @@ fn aiur_fn_120(
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_120] = [__v_14];
-        if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_125] = [__v_14];
+        if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -11509,15 +12033,15 @@ fn aiur_fn_120(
   })
 }
 
-const INPUT_SIZE_121: usize = 10;
-const IN_121: usize = 10;
-const OUT_121: usize = 2;
-fn aiur_fn_121(
-  inp: [G; IN_121],
+const INPUT_SIZE_126: usize = 10;
+const IN_126: usize = 10;
+const OUT_126: usize = 2;
+fn aiur_fn_126(
+  inp: [G; IN_126],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_121], ExecError> {
+) -> Result<[G; OUT_126], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11534,43 +12058,43 @@ fn aiur_fn_121(
         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_121] = [__v_0, __v_12];
-        if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_126] = [__v_0, __v_12];
+        if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__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[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__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[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
         let __v_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_154] = { let __args: [G; IN_154] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         let __v_16: G = __r_arr[2];
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { 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_17: G = __r_arr[0];
         let __v_18: G = G::from_u64(0);
         if (__v_17 != __v_18) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
         }
-        let __ret: [G; OUT_121] = [__v_15, __v_16];
-        if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_126] = [__v_15, __v_16];
+        if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_122: usize = 4;
-const IN_122: usize = 4;
-const OUT_122: usize = 2;
-fn aiur_fn_122(
-  inp: [G; IN_122],
+const INPUT_SIZE_127: usize = 4;
+const IN_127: usize = 4;
+const OUT_127: usize = 2;
+fn aiur_fn_127(
+  inp: [G; IN_127],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_122], ExecError> {
+) -> Result<[G; OUT_127], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11585,8 +12109,8 @@ fn aiur_fn_122(
         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_122] = [__v_9, __v_0];
-        if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_127] = [__v_9, __v_0];
+        if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -11603,12 +12127,12 @@ fn aiur_fn_122(
         let __v_16: G = __loaded[9];
         match __v_7.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_18: G = __r_arr[0];
             let __v_19: G = __r_arr[1];
-            let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
             let __v_21: G = __r_arr[1];
             let __v_22: G = __r_arr[2];
@@ -11627,7 +12151,7 @@ fn aiur_fn_122(
             let __v_35: G = __r_arr[15];
             let __v_36: G = __r_arr[16];
             let __v_37: G = __r_arr[17];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } };
             let __v_38: G = __r_arr[0];
             let __v_39: G = __r_arr[1];
             let __v_40: G = G::from_u64(0);
@@ -11674,8 +12198,8 @@ fn aiur_fn_122(
             let __v_81: G = (__v_63 + __v_80);
             let __v_82: G = (__v_28 + __v_81);
             let __v_83: G = { let __values: [G; 4] = [__v_40, __v_61, __v_82, __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_122] = [__v_83, __v_39];
-            if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_127] = [__v_83, __v_39];
+            if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -11690,15 +12214,15 @@ fn aiur_fn_122(
   })
 }
 
-const INPUT_SIZE_123: usize = 5;
-const IN_123: usize = 5;
-const OUT_123: usize = 1;
-fn aiur_fn_123(
-  inp: [G; IN_123],
+const INPUT_SIZE_128: usize = 5;
+const IN_128: usize = 5;
+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_123], 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];
@@ -11708,12 +12232,12 @@ fn aiur_fn_123(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_123] = [__v_5];
-        if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_128] = [__v_5];
+        if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = (__v_1 - __v_4);
         let __v_7: G = (__v_5 + __v_6);
@@ -11721,8 +12245,8 @@ fn aiur_fn_123(
         match __v_8.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(1);
-            let __ret: [G; OUT_123] = [__v_9];
-            if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_128] = [__v_9];
+            if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -11730,10 +12254,10 @@ fn aiur_fn_123(
             let __v_10: G = (__v_2 - __v_9);
             let __v_11: G = G::from_u64(1);
             let __v_12: G = (__v_3 + __v_11);
-            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_123] = [__v_13];
-            if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_128] = [__v_13];
+            if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -11742,15 +12266,15 @@ fn aiur_fn_123(
   })
 }
 
-const INPUT_SIZE_124: usize = 4;
-const IN_124: usize = 4;
-const OUT_124: usize = 1;
-fn aiur_fn_124(
-  inp: [G; IN_124],
+const INPUT_SIZE_129: usize = 4;
+const IN_129: usize = 4;
+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_124], 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];
@@ -11761,22 +12285,22 @@ fn aiur_fn_124(
         let __v_4: G = G::from_u64(1);
         let __v_5: G = G::from_u64(1);
         let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_124] = [__v_6];
-        if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_129] = [__v_6];
+        if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { 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_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_3 - __v_6);
-            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { 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_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_124] = [__v_8];
-            if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_129] = [__v_8];
+            if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -11787,11 +12311,11 @@ fn aiur_fn_124(
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(1);
             let __v_12: G = (__v_3 - __v_11);
-            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { 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_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_124] = [__v_14];
-            if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_129] = [__v_14];
+            if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -11800,15 +12324,15 @@ fn aiur_fn_124(
   })
 }
 
-const INPUT_SIZE_125: usize = 8;
-const IN_125: usize = 8;
-const OUT_125: usize = 1;
-fn aiur_fn_125(
-  inp: [G; IN_125],
+const INPUT_SIZE_130: usize = 8;
+const IN_130: usize = 8;
+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_125], ExecError> {
+) -> Result<[G; OUT_130], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11831,8 +12355,8 @@ fn aiur_fn_125(
         let __v_15: G = G::from_u64(1);
         let __v_16: G = G::from_u64(1);
         let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_125] = [__v_17];
-        if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_130] = [__v_17];
+        if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -11844,7 +12368,7 @@ fn aiur_fn_125(
               1u64 => {
                 let __v_17: G = G::from_u64(0);
                 let __v_18: G = G::from_u64(0);
-                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_18, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_120] = { let __args: [G; IN_120] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_18, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
                 let __v_19: G = __r_arr[0];
                 let __v_20: G = __r_arr[1];
                 let __v_21: G = __r_arr[2];
@@ -11861,17 +12385,17 @@ fn aiur_fn_125(
                 let __v_32: G = (__v_13 + __v_30);
                 let __v_33: G = G::from_u64(0);
                 let __v_34: G = { let __values: [G; 7] = [__v_33, __v_9, __v_21, __v_22, __v_31, __v_32, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_125] = [__v_34];
-                if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_130] = [__v_34];
+                if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_17: G = G::from_u64(0);
-                let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
                 let __v_18: G = __r_arr[0];
                 let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_125] = [__v_19];
-                if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_130] = [__v_19];
+                if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -11885,15 +12409,15 @@ fn aiur_fn_125(
   })
 }
 
-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_131: usize = 2;
+const IN_131: usize = 2;
+const OUT_131: usize = 1;
+fn aiur_fn_131(
+  inp: [G; IN_131],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_126], ExecError> {
+) -> Result<[G; OUT_131], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11908,8 +12432,8 @@ fn aiur_fn_126(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(1);
-        let __ret: [G; OUT_126] = [__v_9];
-        if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_131] = [__v_9];
+        if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -11931,15 +12455,15 @@ fn aiur_fn_126(
                   return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
                 }
                 let __v_19: G = G::from_u64(1);
-                let __ret: [G; OUT_126] = [__v_19];
-                if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_131] = [__v_19];
+                if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_131] = { let __args: [G; IN_131] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_126] = [__v_11];
-                if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_131] = [__v_11];
+                if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -11953,29 +12477,29 @@ fn aiur_fn_126(
   })
 }
 
-const INPUT_SIZE_127: usize = 2;
-const IN_127: usize = 2;
-const OUT_127: usize = 1;
-fn aiur_fn_127(
-  inp: [G; IN_127],
+const INPUT_SIZE_132: usize = 2;
+const IN_132: usize = 2;
+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_127], 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];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_127] = [__v_2];
-        if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_132] = [__v_2];
+        if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
         let __v_2: G = G::from_u64(1);
-        let __ret: [G; OUT_127] = [__v_2];
-        if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_132] = [__v_2];
+        if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -11985,15 +12509,15 @@ fn aiur_fn_127(
   })
 }
 
-const INPUT_SIZE_128: usize = 10;
-const IN_128: usize = 10;
-const OUT_128: usize = 1;
-fn aiur_fn_128(
-  inp: [G; IN_128],
+const INPUT_SIZE_133: usize = 10;
+const IN_133: usize = 10;
+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_128], 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];
@@ -12006,17 +12530,17 @@ fn aiur_fn_128(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = (__v_3 - __v_1);
-    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(7);
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     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_111] = { let __args: [G; IN_111] = [__v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_13, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { 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_18: G = __r_arr[0];
     let __v_19: G = (__v_12 * __v_18);
     let __v_20: G = G::from_u64(0);
@@ -12045,9 +12569,9 @@ fn aiur_fn_128(
     let __v_37: G = G::from_u64(0);
     let __v_38: G = (__v_37 - __v_22);
     let __v_39: G = (__v_38 * __v_28);
-    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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
     let __v_40: G = __r_arr[0];
-    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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
     let __v_41: G = __r_arr[0];
     let __v_42: G = (__v_40 - __v_41);
     let __v_43: G = G::from_bool((__v_42 == G::ZERO));
@@ -12055,23 +12579,23 @@ fn aiur_fn_128(
     if (__v_43 != __v_44) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None });
     }
-    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1, __v_6, __v_7, __v_36, __v_39, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1, __v_6, __v_7, __v_36, __v_39, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
     let __v_45: G = __r_arr[0];
-    let __ret: [G; OUT_128] = [__v_45];
-    if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_133] = [__v_45];
+    if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_129: usize = 11;
-const IN_129: usize = 11;
-const OUT_129: usize = 1;
-fn aiur_fn_129(
-  inp: [G; IN_129],
+const INPUT_SIZE_134: usize = 11;
+const IN_134: usize = 11;
+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_129], ExecError> {
+) -> Result<[G; OUT_134], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12085,12 +12609,12 @@ fn aiur_fn_129(
     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_192] = { let __args: [G; IN_192] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
     let __v_13: G = G::from_u64(1);
-    let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
     let __v_16: G = G::from_u64(0);
     let __v_17: G = (__v_5 * __v_15);
@@ -12101,25 +12625,25 @@ fn aiur_fn_129(
     let __v_22: G = (__v_5 * __v_16);
     let __v_23: G = (__v_6 * __v_15);
     let __v_24: G = (__v_22 + __v_23);
-    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { 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_133] = { let __args: [G; IN_133] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_25, __v_3, __v_1, __v_2, __v_21, __v_24, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { 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_133] = { let __args: [G; IN_133] = [__v_25, __v_3, __v_1, __v_2, __v_21, __v_24, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_26: G = __r_arr[0];
-    let __ret: [G; OUT_129] = [__v_26];
-    if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_134] = [__v_26];
+    if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_130: usize = 13;
-const IN_130: usize = 13;
-const OUT_130: usize = 1;
-fn aiur_fn_130(
-  inp: [G; IN_130],
+const INPUT_SIZE_135: usize = 13;
+const IN_135: usize = 13;
+const OUT_135: usize = 1;
+fn aiur_fn_135(
+  inp: [G; IN_135],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_130], 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];
@@ -12136,43 +12660,43 @@ fn aiur_fn_130(
     let __v_12: G = inp[12];
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_130] = [__v_0];
-        if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_135] = [__v_0];
+        if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = (__v_13 + __v_3);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
         let __v_17: G = __r_arr[0];
         let __v_18: G = G::from_u64(1);
         let __v_19: G = (__v_4 + __v_18);
         let __v_20: G = G::from_u64(1);
         let __v_21: G = (__v_5 - __v_20);
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_21, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { 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_135] = { let __args: [G; IN_135] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_21, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { 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_22: G = __r_arr[0];
-        let __ret: [G; OUT_130] = [__v_22];
-        if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_135] = [__v_22];
+        if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_131: usize = 13;
-const IN_131: usize = 13;
-const OUT_131: usize = 1;
-fn aiur_fn_131(
-  inp: [G; IN_131],
+const INPUT_SIZE_136: usize = 13;
+const IN_136: usize = 13;
+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_131], 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];
@@ -12189,46 +12713,46 @@ fn aiur_fn_131(
     let __v_12: G = inp[12];
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_131] = [__v_0];
-        if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_136] = [__v_0];
+        if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = (__v_13 + __v_3);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __v_17: G = G::from_u64(0);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { 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_133] = { let __args: [G; IN_133] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_19: G = __r_arr[0];
         let __v_20: G = G::from_u64(1);
         let __v_21: G = (__v_4 + __v_20);
         let __v_22: G = G::from_u64(1);
         let __v_23: G = (__v_5 - __v_22);
-        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_23, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_23, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { 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_24: G = __r_arr[0];
-        let __ret: [G; OUT_131] = [__v_24];
-        if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_136] = [__v_24];
+        if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_132: usize = 15;
-const IN_132: usize = 15;
-const OUT_132: usize = 1;
-fn aiur_fn_132(
-  inp: [G; IN_132],
+const INPUT_SIZE_137: usize = 15;
+const IN_137: usize = 15;
+const OUT_137: usize = 1;
+fn aiur_fn_137(
+  inp: [G; IN_137],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_132], 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];
@@ -12247,12 +12771,12 @@ fn aiur_fn_132(
     let __v_14: G = inp[14];
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_132] = [__v_0];
-        if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_137] = [__v_0];
+        if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
         let __v_15: G = __r_arr[0];
         let __v_16: G = __r_arr[1];
         match __v_15.as_canonical_u64() {
@@ -12261,21 +12785,21 @@ fn aiur_fn_132(
             let __v_18: G = (__v_4 + __v_17);
             let __v_19: G = G::from_u64(1);
             let __v_20: G = (__v_5 - __v_19);
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { 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_21: G = __r_arr[0];
-            let __ret: [G; OUT_132] = [__v_21];
-            if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_137] = [__v_21];
+            if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __v_18: G = (__v_17 + __v_3);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_19: G = __r_arr[0];
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
-            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = G::from_u64(1);
             let __v_23: G = (__v_4 + __v_22);
@@ -12283,10 +12807,10 @@ fn aiur_fn_132(
             let __v_25: G = (__v_5 - __v_24);
             let __v_26: G = G::from_u64(1);
             let __v_27: G = (__v_6 + __v_26);
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_25, __v_27, __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[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_25, __v_27, __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[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { 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_28: G = __r_arr[0];
-            let __ret: [G; OUT_132] = [__v_28];
-            if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_137] = [__v_28];
+            if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -12298,15 +12822,15 @@ fn aiur_fn_132(
   })
 }
 
-const INPUT_SIZE_133: usize = 15;
-const IN_133: usize = 15;
-const OUT_133: usize = 1;
-fn aiur_fn_133(
-  inp: [G; IN_133],
+const INPUT_SIZE_138: usize = 15;
+const IN_138: usize = 15;
+const OUT_138: usize = 1;
+fn aiur_fn_138(
+  inp: [G; IN_138],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_133], 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];
@@ -12325,47 +12849,37 @@ fn aiur_fn_133(
     let __v_14: G = inp[14];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_133] = [__v_0];
-        if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_138] = [__v_0];
+        if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
         let __v_15: G = G::from_u64(3);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
-        let __v_17: G = __r_arr[1];
         match __v_16.as_canonical_u64() {
           _ => {
-            let __v_18: G = G::from_u64(0);
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_6, __v_10, __v_5, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { 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_17: G = G::from_u64(0);
+            let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_6, __v_10, __v_5, __v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { 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_18: G = __r_arr[0];
+            let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
             let __v_19: G = __r_arr[0];
-            let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { 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_206] = { let __args: [G; IN_206] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
-            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
-            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __v_23: G = (__v_21 - __v_22);
-            let __v_24: G = G::from_bool((__v_23 == G::ZERO));
-            let __v_25: G = G::from_u64(1);
-            if (__v_24 != __v_25) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None });
+            let __v_22: G = (__v_20 - __v_21);
+            let __v_23: G = G::from_bool((__v_22 == G::ZERO));
+            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(), msg: None });
             }
-            let __v_26: G = (__v_9 - __v_20);
-            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+            let __v_25: G = G::from_u64(0);
+            let __v_26: G = G::from_u64(0);
+            let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_8, __v_9, __v_10, __v_25, __v_7, __v_26, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { 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_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_2, __v_16, __v_19, __v_27, __v_17, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { 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_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(), msg: None });
-            }
-            let __v_30: G = G::from_u64(0);
-            let __v_31: G = G::from_u64(0);
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_8, __v_9, __v_10, __v_30, __v_7, __v_31, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
-            let __v_32: G = __r_arr[0];
-            let __ret: [G; OUT_133] = [__v_32];
-            if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_138] = [__v_27];
+            if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -12377,15 +12891,15 @@ fn aiur_fn_133(
   })
 }
 
-const INPUT_SIZE_134: usize = 4;
-const IN_134: usize = 4;
-const OUT_134: usize = 1;
-fn aiur_fn_134(
-  inp: [G; IN_134],
+const INPUT_SIZE_139: usize = 4;
+const IN_139: usize = 4;
+const OUT_139: usize = 1;
+fn aiur_fn_139(
+  inp: [G; IN_139],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_134], 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];
@@ -12396,39 +12910,39 @@ fn aiur_fn_134(
         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_134] = [__v_6];
-        if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_139] = [__v_6];
+        if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = (__v_5 + __v_1);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_2 - __v_7);
         let __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_3 + __v_9);
-        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
         let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_134] = [__v_12];
-        if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_139] = [__v_12];
+        if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_135: usize = 1;
-const IN_135: usize = 1;
-const OUT_135: usize = 1;
-fn aiur_fn_135(
-  inp: [G; IN_135],
+const INPUT_SIZE_140: usize = 1;
+const IN_140: usize = 1;
+const OUT_140: usize = 1;
+fn aiur_fn_140(
+  inp: [G; IN_140],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_135], ExecError> {
+) -> Result<[G; OUT_140], 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 };
@@ -12438,23 +12952,23 @@ fn aiur_fn_135(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_135] = [__v_4];
-        if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_140] = [__v_4];
+        if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { 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_140] = { let __args: [G; IN_140] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_135] = [__v_4];
-            if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_140] = [__v_4];
+            if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_135] = [__v_2];
-            if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_140] = [__v_2];
+            if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -12466,15 +12980,15 @@ fn aiur_fn_135(
   })
 }
 
-const INPUT_SIZE_136: usize = 5;
-const IN_136: usize = 5;
-const OUT_136: usize = 1;
-fn aiur_fn_136(
-  inp: [G; IN_136],
+const INPUT_SIZE_141: usize = 5;
+const IN_141: usize = 5;
+const OUT_141: usize = 1;
+fn aiur_fn_141(
+  inp: [G; IN_141],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_136], 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];
@@ -12486,12 +13000,12 @@ fn aiur_fn_136(
         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_136] = [__v_7];
-        if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_141] = [__v_7];
+        if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
         match __v_5.as_canonical_u64() {
@@ -12500,26 +13014,26 @@ fn aiur_fn_136(
             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_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { 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_141] = { let __args: [G; IN_141] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { 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_11: G = __r_arr[0];
-            let __ret: [G; OUT_136] = [__v_11];
-            if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_141] = [__v_11];
+            if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
             let __v_7: G = G::from_u64(0);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __v_9: G = (__v_8 + __v_1);
             let __v_10: G = G::from_u64(1);
             let __v_11: G = (__v_3 - __v_10);
             let __v_12: G = G::from_u64(1);
             let __v_13: G = (__v_4 + __v_12);
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { 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_141] = { let __args: [G; IN_141] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { 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_14: G = __r_arr[0];
             let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_136] = [__v_15];
-            if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_141] = [__v_15];
+            if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -12531,15 +13045,15 @@ fn aiur_fn_136(
   })
 }
 
-const INPUT_SIZE_137: usize = 5;
-const IN_137: usize = 5;
-const OUT_137: usize = 4;
-fn aiur_fn_137(
-  inp: [G; IN_137],
+const INPUT_SIZE_142: usize = 5;
+const IN_142: usize = 5;
+const OUT_142: usize = 4;
+fn aiur_fn_142(
+  inp: [G; IN_142],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_137], 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];
@@ -12548,28 +13062,28 @@ fn aiur_fn_137(
     let __v_4: G = inp[4];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_137] = [__v_1, __v_2, __v_3, __v_4];
-        if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_142] = [__v_1, __v_2, __v_3, __v_4];
+        if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_137] = [__v_3, __v_4, __v_1, __v_2];
-        if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_142] = [__v_3, __v_4, __v_1, __v_2];
+        if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_138: usize = 4;
-const IN_138: usize = 4;
-const OUT_138: usize = 1;
-fn aiur_fn_138(
-  inp: [G; IN_138],
+const INPUT_SIZE_143: usize = 4;
+const IN_143: usize = 4;
+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_138], 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];
@@ -12810,21 +13324,21 @@ fn aiur_fn_138(
     let __v_192: G = { let __values: [G; 10] = [__v_132, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_191]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_193: G = { let __values: [G; 10] = [__v_104, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_192]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_194: G = { let __values: [G; 10] = [__v_76, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_193]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_138] = [__v_194];
-    if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_143] = [__v_194];
+    if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_139: usize = 6;
-const IN_139: usize = 6;
-const OUT_139: usize = 3;
-fn aiur_fn_139(
-  inp: [G; IN_139],
+const INPUT_SIZE_144: usize = 6;
+const IN_144: usize = 6;
+const OUT_144: usize = 3;
+fn aiur_fn_144(
+  inp: [G; IN_144],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_139], 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];
@@ -12842,8 +13356,8 @@ fn aiur_fn_139(
     let __v_12: G = __loaded[6];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_139] = [__v_0, __v_1, __v_5];
-        if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_144] = [__v_0, __v_1, __v_5];
+        if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -12854,7 +13368,7 @@ fn aiur_fn_139(
             match __v_14.as_canonical_u64() {
               1u64 => {
                 let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
                 let __v_16: G = __r_arr[0];
                 let __v_17: G = __r_arr[1];
                 let __v_18: G = (__v_16 * __v_10);
@@ -12867,13 +13381,13 @@ fn aiur_fn_139(
                 let __v_25: G = (__v_23 + __v_24);
                 let __v_26: G = (__v_0 + __v_22);
                 let __v_27: G = (__v_1 + __v_25);
-                let __ret: [G; OUT_139] = [__v_26, __v_27, __v_12];
-                if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_144] = [__v_26, __v_27, __v_12];
+                if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
-                let __ret: [G; OUT_139] = [__v_0, __v_1, __v_5];
-                if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_144] = [__v_0, __v_1, __v_5];
+                if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -12887,15 +13401,15 @@ fn aiur_fn_139(
   })
 }
 
-const INPUT_SIZE_140: usize = 9;
-const IN_140: usize = 9;
-const OUT_140: usize = 2;
-fn aiur_fn_140(
-  inp: [G; IN_140],
+const INPUT_SIZE_145: usize = 9;
+const IN_145: usize = 9;
+const OUT_145: usize = 3;
+fn aiur_fn_145(
+  inp: [G; IN_145],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_140], ExecError> {
+) -> Result<[G; OUT_145], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12906,356 +13420,345 @@ fn aiur_fn_140(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    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 __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_9: G = __loaded[0];
     let __v_10: G = __loaded[1];
     let __v_11: G = __loaded[2];
     let __v_12: G = __loaded[3];
-    let __v_13: G = __loaded[4];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __v_14: G = (__v_6 - __v_8);
-        let __v_15: G = G::from_bool((__v_14 == G::ZERO));
-        let __v_16: G = G::from_u64(1);
-        if (__v_15 != __v_16) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None });
+        let __v_13: G = (__v_6 - __v_8);
+        let __v_14: G = G::from_bool((__v_13 == G::ZERO));
+        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(), msg: None });
         }
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __v_18: G = G::from_u64(0);
-        if (__v_17 != __v_18) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
+        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __v_17: G = G::from_u64(0);
+        if (__v_16 != __v_17) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None });
         }
-        let __ret: [G; OUT_140] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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_145] = [__v_0, __v_1, __v_20];
+        if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_14: G = __loaded[0];
-        let __v_15: G = __loaded[1];
-        let __v_16: G = __loaded[2];
-        let __v_17: G = __loaded[3];
-        match __v_14.as_canonical_u64() {
+        let __v_13: G = __loaded[0];
+        let __v_14: G = __loaded[1];
+        let __v_15: G = __loaded[2];
+        let __v_16: G = __loaded[3];
+        match __v_13.as_canonical_u64() {
           0u64 => {
             let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_18: G = __loaded[0];
-            let __v_19: G = __loaded[1];
-            let __v_20: G = __loaded[2];
-            match __v_18.as_canonical_u64() {
+            let __v_17: G = __loaded[0];
+            let __v_18: G = __loaded[1];
+            let __v_19: G = __loaded[2];
+            match __v_17.as_canonical_u64() {
               0u64 => {
                 match __v_10.as_canonical_u64() {
                   _ => {
                     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                    let __v_21: G = __loaded[0];
-                    let __v_22: G = __loaded[1];
-                    let __v_23: G = __loaded[2];
-                    match __v_21.as_canonical_u64() {
+                    let __v_20: G = __loaded[0];
+                    let __v_21: G = __loaded[1];
+                    let __v_22: G = __loaded[2];
+                    match __v_20.as_canonical_u64() {
                       0u64 => {
-                        let __v_24: G = G::from_u64(1);
-                        let __v_25: G = (__v_6 - __v_24);
-                        let __v_26: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_11, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                        let __v_27: G = __r_arr[0];
-                        let __v_28: G = __r_arr[1];
-                        let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_22.as_canonical_u64() {
+                        let __v_23: G = G::from_u64(1);
+                        let __v_24: G = (__v_6 - __v_23);
+                        let __v_25: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_11, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+                        let __v_26: G = __r_arr[0];
+                        let __v_27: G = __r_arr[1];
+                        let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_21.as_canonical_u64() {
   0u64 => {
-    break '__mc_0 [__v_0, __v_1, __v_27, __v_28];
+    break '__mc_0 [__v_0, __v_1, __v_26, __v_27];
   },
   _ => {
-    break '__mc_0 [__v_27, __v_28, __v_0, __v_1];
+    break '__mc_0 [__v_26, __v_27, __v_0, __v_1];
   },
 }
  };
-                        let __v_29: G = __mc_out___mc_0[0];
-                        let __v_30: G = __mc_out___mc_0[1];
-                        let __v_31: G = __mc_out___mc_0[2];
-                        let __v_32: G = __mc_out___mc_0[3];
+                        let __v_28: G = __mc_out___mc_0[0];
+                        let __v_29: G = __mc_out___mc_0[1];
+                        let __v_30: G = __mc_out___mc_0[2];
+                        let __v_31: G = __mc_out___mc_0[3];
+                        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_22, __v_24, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                        let __v_32: G = __r_arr[0];
+                        let __v_33: G = __r_arr[1];
+                        let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_32, __v_33, __v_24, __v_14, __v_15, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
+                        let __v_34: G = __r_arr[0];
+                        let __v_35: G = __r_arr[1];
+                        let __v_36: G = __r_arr[2];
+                        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_34, __v_35, __v_16, __v_19, __v_12, __v_22, __v_24, __v_36, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
+                        let __v_37: G = __r_arr[0];
+                        let __v_38: G = __r_arr[1];
+                        let __v_39: G = __r_arr[2];
+                        let __gb: [u8; 8] = __v_28.as_canonical_u64().to_le_bytes();
+                        let __v_40: G = G::from_u8(__gb[0]);
+                        let __v_41: G = G::from_u8(__gb[1]);
+                        let __v_42: G = G::from_u8(__gb[2]);
+                        let __v_43: G = G::from_u8(__gb[3]);
+                        let __v_44: G = G::from_u8(__gb[4]);
+                        let __v_45: G = G::from_u8(__gb[5]);
+                        let __v_46: G = G::from_u8(__gb[6]);
+                        let __v_47: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_44; let __vj = __v_45; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_46; let __vj = __v_47; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        let __v_48: G = G::from_u64(1020);
+                        let __v_49: G = (__v_47 - __v_48);
+                        let __v_50: G = (__v_46 + __v_49);
+                        let __v_51: G = (__v_45 + __v_50);
+                        let __v_52: G = (__v_44 + __v_51);
+                        let __v_53: G = G::from_bool((__v_52 == G::ZERO));
+                        let __v_54: G = (__v_42 + __v_43);
+                        let __v_55: G = (__v_41 + __v_54);
+                        let __v_56: G = (__v_40 + __v_55);
+                        let __v_57: G = G::from_bool((__v_56 == G::ZERO));
                         let __gb: [u8; 8] = __v_29.as_canonical_u64().to_le_bytes();
-                        let __v_33: G = G::from_u8(__gb[0]);
-                        let __v_34: G = G::from_u8(__gb[1]);
-                        let __v_35: G = G::from_u8(__gb[2]);
-                        let __v_36: G = G::from_u8(__gb[3]);
-                        let __v_37: G = G::from_u8(__gb[4]);
-                        let __v_38: G = G::from_u8(__gb[5]);
-                        let __v_39: G = G::from_u8(__gb[6]);
-                        let __v_40: G = G::from_u8(__gb[7]);
-                        if !unconstrained { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        let __v_41: G = G::from_u64(1020);
-                        let __v_42: G = (__v_40 - __v_41);
-                        let __v_43: G = (__v_39 + __v_42);
-                        let __v_44: G = (__v_38 + __v_43);
-                        let __v_45: G = (__v_37 + __v_44);
-                        let __v_46: G = G::from_bool((__v_45 == G::ZERO));
-                        let __v_47: G = (__v_35 + __v_36);
-                        let __v_48: G = (__v_34 + __v_47);
-                        let __v_49: G = (__v_33 + __v_48);
-                        let __v_50: G = G::from_bool((__v_49 == G::ZERO));
+                        let __v_58: G = G::from_u8(__gb[0]);
+                        let __v_59: G = G::from_u8(__gb[1]);
+                        let __v_60: G = G::from_u8(__gb[2]);
+                        let __v_61: G = G::from_u8(__gb[3]);
+                        let __v_62: G = G::from_u8(__gb[4]);
+                        let __v_63: G = G::from_u8(__gb[5]);
+                        let __v_64: G = G::from_u8(__gb[6]);
+                        let __v_65: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        let __v_66: G = G::from_u64(1020);
+                        let __v_67: G = (__v_65 - __v_66);
+                        let __v_68: G = (__v_64 + __v_67);
+                        let __v_69: G = (__v_63 + __v_68);
+                        let __v_70: G = (__v_62 + __v_69);
+                        let __v_71: G = G::from_bool((__v_70 == G::ZERO));
+                        let __v_72: G = (__v_60 + __v_61);
+                        let __v_73: G = (__v_59 + __v_72);
+                        let __v_74: G = (__v_58 + __v_73);
+                        let __v_75: G = G::from_bool((__v_74 == G::ZERO));
                         let __gb: [u8; 8] = __v_30.as_canonical_u64().to_le_bytes();
-                        let __v_51: G = G::from_u8(__gb[0]);
-                        let __v_52: G = G::from_u8(__gb[1]);
-                        let __v_53: G = G::from_u8(__gb[2]);
-                        let __v_54: G = G::from_u8(__gb[3]);
-                        let __v_55: G = G::from_u8(__gb[4]);
-                        let __v_56: G = G::from_u8(__gb[5]);
-                        let __v_57: G = G::from_u8(__gb[6]);
-                        let __v_58: G = G::from_u8(__gb[7]);
-                        if !unconstrained { let __vi = __v_51; let __vj = __v_52; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_53; let __vj = __v_54; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_55; let __vj = __v_56; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_57; let __vj = __v_58; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        let __v_59: G = G::from_u64(1020);
-                        let __v_60: G = (__v_58 - __v_59);
-                        let __v_61: G = (__v_57 + __v_60);
-                        let __v_62: G = (__v_56 + __v_61);
-                        let __v_63: G = (__v_55 + __v_62);
-                        let __v_64: G = G::from_bool((__v_63 == G::ZERO));
-                        let __v_65: G = (__v_53 + __v_54);
-                        let __v_66: G = (__v_52 + __v_65);
-                        let __v_67: G = (__v_51 + __v_66);
-                        let __v_68: G = G::from_bool((__v_67 == G::ZERO));
+                        let __v_76: G = G::from_u8(__gb[0]);
+                        let __v_77: G = G::from_u8(__gb[1]);
+                        let __v_78: G = G::from_u8(__gb[2]);
+                        let __v_79: G = G::from_u8(__gb[3]);
+                        let __v_80: G = G::from_u8(__gb[4]);
+                        let __v_81: G = G::from_u8(__gb[5]);
+                        let __v_82: G = G::from_u8(__gb[6]);
+                        let __v_83: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_76; let __vj = __v_77; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_78; let __vj = __v_79; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_80; let __vj = __v_81; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_82; let __vj = __v_83; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        let __v_84: G = G::from_u64(1020);
+                        let __v_85: G = (__v_83 - __v_84);
+                        let __v_86: G = (__v_82 + __v_85);
+                        let __v_87: G = (__v_81 + __v_86);
+                        let __v_88: G = (__v_80 + __v_87);
+                        let __v_89: G = G::from_bool((__v_88 == G::ZERO));
+                        let __v_90: G = (__v_78 + __v_79);
+                        let __v_91: G = (__v_77 + __v_90);
+                        let __v_92: G = (__v_76 + __v_91);
+                        let __v_93: G = G::from_bool((__v_92 == G::ZERO));
                         let __gb: [u8; 8] = __v_31.as_canonical_u64().to_le_bytes();
-                        let __v_69: G = G::from_u8(__gb[0]);
-                        let __v_70: G = G::from_u8(__gb[1]);
-                        let __v_71: G = G::from_u8(__gb[2]);
-                        let __v_72: G = G::from_u8(__gb[3]);
-                        let __v_73: G = G::from_u8(__gb[4]);
-                        let __v_74: G = G::from_u8(__gb[5]);
-                        let __v_75: G = G::from_u8(__gb[6]);
-                        let __v_76: G = G::from_u8(__gb[7]);
-                        if !unconstrained { let __vi = __v_69; let __vj = __v_70; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_71; let __vj = __v_72; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_73; let __vj = __v_74; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_75; let __vj = __v_76; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        let __v_77: G = G::from_u64(1020);
-                        let __v_78: G = (__v_76 - __v_77);
-                        let __v_79: G = (__v_75 + __v_78);
-                        let __v_80: G = (__v_74 + __v_79);
-                        let __v_81: G = (__v_73 + __v_80);
-                        let __v_82: G = G::from_bool((__v_81 == G::ZERO));
-                        let __v_83: G = (__v_71 + __v_72);
-                        let __v_84: G = (__v_70 + __v_83);
-                        let __v_85: G = (__v_69 + __v_84);
-                        let __v_86: G = G::from_bool((__v_85 == G::ZERO));
-                        let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes();
-                        let __v_87: G = G::from_u8(__gb[0]);
-                        let __v_88: G = G::from_u8(__gb[1]);
-                        let __v_89: G = G::from_u8(__gb[2]);
-                        let __v_90: G = G::from_u8(__gb[3]);
-                        let __v_91: G = G::from_u8(__gb[4]);
-                        let __v_92: G = G::from_u8(__gb[5]);
-                        let __v_93: G = G::from_u8(__gb[6]);
-                        let __v_94: G = G::from_u8(__gb[7]);
-                        if !unconstrained { let __vi = __v_87; let __vj = __v_88; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_89; let __vj = __v_90; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_91; let __vj = __v_92; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_93; let __vj = __v_94; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        let __v_95: G = G::from_u64(1020);
-                        let __v_96: G = (__v_94 - __v_95);
-                        let __v_97: G = (__v_93 + __v_96);
-                        let __v_98: G = (__v_92 + __v_97);
-                        let __v_99: G = (__v_91 + __v_98);
-                        let __v_100: G = G::from_bool((__v_99 == G::ZERO));
-                        let __v_101: G = (__v_89 + __v_90);
-                        let __v_102: G = (__v_88 + __v_101);
-                        let __v_103: G = (__v_87 + __v_102);
-                        let __v_104: G = G::from_bool((__v_103 == G::ZERO));
-                        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_23, __v_25, __v_15, __v_16, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { 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_105: G = __r_arr[0];
-                        let __v_106: G = __r_arr[1];
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_105, __v_106, __v_25, __v_15, __v_16, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { 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_107: G = __r_arr[0];
-                        let __v_108: G = __r_arr[1];
-                        let __v_109: G = __r_arr[2];
-                        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-                        let __v_110: G = __r_arr[0];
-                        let __v_111: G = G::from_u64(1);
-                        if (__v_110 != __v_111) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_110.as_canonical_u64(), rhs: __v_111.as_canonical_u64(), msg: None });
+                        let __v_94: G = G::from_u8(__gb[0]);
+                        let __v_95: G = G::from_u8(__gb[1]);
+                        let __v_96: G = G::from_u8(__gb[2]);
+                        let __v_97: G = G::from_u8(__gb[3]);
+                        let __v_98: G = G::from_u8(__gb[4]);
+                        let __v_99: G = G::from_u8(__gb[5]);
+                        let __v_100: G = G::from_u8(__gb[6]);
+                        let __v_101: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_94; let __vj = __v_95; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_96; let __vj = __v_97; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_98; let __vj = __v_99; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        if !unconstrained { let __vi = __v_100; let __vj = __v_101; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+                        let __v_102: G = G::from_u64(1020);
+                        let __v_103: G = (__v_101 - __v_102);
+                        let __v_104: G = (__v_100 + __v_103);
+                        let __v_105: G = (__v_99 + __v_104);
+                        let __v_106: G = (__v_98 + __v_105);
+                        let __v_107: G = G::from_bool((__v_106 == G::ZERO));
+                        let __v_108: G = (__v_96 + __v_97);
+                        let __v_109: G = (__v_95 + __v_108);
+                        let __v_110: G = (__v_94 + __v_109);
+                        let __v_111: G = G::from_bool((__v_110 == G::ZERO));
+                        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+                        let __v_112: G = __r_arr[0];
+                        let __v_113: G = G::from_u64(1);
+                        if (__v_112 != __v_113) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_112.as_canonical_u64(), rhs: __v_113.as_canonical_u64(), msg: None });
                         }
-                        let __v_112: G = G::from_u64(0);
-                        let __v_113: G = G::from_u64(0);
-                        let __v_114: G = G::from_u64(256);
-                        let __v_115: G = (__v_114 * __v_34);
-                        let __v_116: G = G::from_u64(65536);
-                        let __v_117: G = (__v_116 * __v_35);
-                        let __v_118: G = G::from_u64(16777216);
-                        let __v_119: G = (__v_118 * __v_36);
-                        let __v_120: G = G::from_u64(4294967296);
-                        let __v_121: G = (__v_120 * __v_37);
-                        let __v_122: G = G::from_u64(1099511627776);
-                        let __v_123: G = (__v_122 * __v_38);
-                        let __v_124: G = G::from_u64(281474976710656);
-                        let __v_125: G = (__v_124 * __v_39);
-                        let __v_126: G = G::from_u64(72057594037927936);
-                        let __v_127: G = (__v_126 * __v_40);
-                        let __v_128: G = (__v_125 + __v_127);
-                        let __v_129: G = (__v_123 + __v_128);
-                        let __v_130: G = (__v_121 + __v_129);
-                        let __v_131: G = (__v_119 + __v_130);
-                        let __v_132: G = (__v_117 + __v_131);
-                        let __v_133: G = (__v_115 + __v_132);
-                        let __v_134: G = (__v_33 + __v_133);
-                        if (__v_134 != __v_29) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_134.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None });
+                        let __v_114: G = G::from_u64(0);
+                        let __v_115: G = G::from_u64(0);
+                        let __v_116: G = G::from_u64(256);
+                        let __v_117: G = (__v_116 * __v_41);
+                        let __v_118: G = G::from_u64(65536);
+                        let __v_119: G = (__v_118 * __v_42);
+                        let __v_120: G = G::from_u64(16777216);
+                        let __v_121: G = (__v_120 * __v_43);
+                        let __v_122: G = G::from_u64(4294967296);
+                        let __v_123: G = (__v_122 * __v_44);
+                        let __v_124: G = G::from_u64(1099511627776);
+                        let __v_125: G = (__v_124 * __v_45);
+                        let __v_126: G = G::from_u64(281474976710656);
+                        let __v_127: G = (__v_126 * __v_46);
+                        let __v_128: G = G::from_u64(72057594037927936);
+                        let __v_129: G = (__v_128 * __v_47);
+                        let __v_130: G = (__v_127 + __v_129);
+                        let __v_131: G = (__v_125 + __v_130);
+                        let __v_132: G = (__v_123 + __v_131);
+                        let __v_133: G = (__v_121 + __v_132);
+                        let __v_134: G = (__v_119 + __v_133);
+                        let __v_135: G = (__v_117 + __v_134);
+                        let __v_136: G = (__v_40 + __v_135);
+                        if (__v_136 != __v_28) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None });
                         }
-                        let __v_135: G = G::from_u64(1);
-                        let __v_136: G = G::from_u64(1);
-                        let __v_137: G = (__v_136 - __v_50);
-                        let __v_138: G = (__v_46 * __v_137);
-                        let __v_139: G = (__v_135 - __v_138);
-                        let __v_140: G = G::from_u64(1);
-                        if (__v_139 != __v_140) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: None });
+                        let __v_137: G = G::from_u64(1);
+                        let __v_138: G = G::from_u64(1);
+                        let __v_139: G = (__v_138 - __v_57);
+                        let __v_140: G = (__v_53 * __v_139);
+                        let __v_141: G = (__v_137 - __v_140);
+                        let __v_142: G = G::from_u64(1);
+                        if (__v_141 != __v_142) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_142.as_canonical_u64(), msg: None });
                         }
-                        let __v_141: G = G::from_u64(0);
-                        let __v_142: G = G::from_u64(256);
-                        let __v_143: G = (__v_142 * __v_52);
-                        let __v_144: G = G::from_u64(65536);
-                        let __v_145: G = (__v_144 * __v_53);
-                        let __v_146: G = G::from_u64(16777216);
-                        let __v_147: G = (__v_146 * __v_54);
-                        let __v_148: G = G::from_u64(4294967296);
-                        let __v_149: G = (__v_148 * __v_55);
-                        let __v_150: G = G::from_u64(1099511627776);
-                        let __v_151: G = (__v_150 * __v_56);
-                        let __v_152: G = G::from_u64(281474976710656);
-                        let __v_153: G = (__v_152 * __v_57);
-                        let __v_154: G = G::from_u64(72057594037927936);
-                        let __v_155: G = (__v_154 * __v_58);
-                        let __v_156: G = (__v_153 + __v_155);
-                        let __v_157: G = (__v_151 + __v_156);
-                        let __v_158: G = (__v_149 + __v_157);
-                        let __v_159: G = (__v_147 + __v_158);
-                        let __v_160: G = (__v_145 + __v_159);
-                        let __v_161: G = (__v_143 + __v_160);
-                        let __v_162: G = (__v_51 + __v_161);
-                        if (__v_162 != __v_30) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_162.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None });
+                        let __v_143: G = G::from_u64(0);
+                        let __v_144: G = G::from_u64(256);
+                        let __v_145: G = (__v_144 * __v_59);
+                        let __v_146: G = G::from_u64(65536);
+                        let __v_147: G = (__v_146 * __v_60);
+                        let __v_148: G = G::from_u64(16777216);
+                        let __v_149: G = (__v_148 * __v_61);
+                        let __v_150: G = G::from_u64(4294967296);
+                        let __v_151: G = (__v_150 * __v_62);
+                        let __v_152: G = G::from_u64(1099511627776);
+                        let __v_153: G = (__v_152 * __v_63);
+                        let __v_154: G = G::from_u64(281474976710656);
+                        let __v_155: G = (__v_154 * __v_64);
+                        let __v_156: G = G::from_u64(72057594037927936);
+                        let __v_157: G = (__v_156 * __v_65);
+                        let __v_158: G = (__v_155 + __v_157);
+                        let __v_159: G = (__v_153 + __v_158);
+                        let __v_160: G = (__v_151 + __v_159);
+                        let __v_161: G = (__v_149 + __v_160);
+                        let __v_162: G = (__v_147 + __v_161);
+                        let __v_163: G = (__v_145 + __v_162);
+                        let __v_164: G = (__v_58 + __v_163);
+                        if (__v_164 != __v_29) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_164.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None });
                         }
-                        let __v_163: G = G::from_u64(1);
-                        let __v_164: G = G::from_u64(1);
-                        let __v_165: G = (__v_164 - __v_68);
-                        let __v_166: G = (__v_64 * __v_165);
-                        let __v_167: G = (__v_163 - __v_166);
-                        let __v_168: G = G::from_u64(1);
-                        if (__v_167 != __v_168) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_168.as_canonical_u64(), msg: None });
+                        let __v_165: G = G::from_u64(1);
+                        let __v_166: G = G::from_u64(1);
+                        let __v_167: G = (__v_166 - __v_75);
+                        let __v_168: G = (__v_71 * __v_167);
+                        let __v_169: G = (__v_165 - __v_168);
+                        let __v_170: G = G::from_u64(1);
+                        if (__v_169 != __v_170) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_170.as_canonical_u64(), msg: None });
                         }
-                        let __v_169: G = G::from_u64(0);
-                        let __v_170: G = G::from_u64(256);
-                        let __v_171: G = (__v_170 * __v_70);
-                        let __v_172: G = G::from_u64(65536);
-                        let __v_173: G = (__v_172 * __v_71);
-                        let __v_174: G = G::from_u64(16777216);
-                        let __v_175: G = (__v_174 * __v_72);
-                        let __v_176: G = G::from_u64(4294967296);
-                        let __v_177: G = (__v_176 * __v_73);
-                        let __v_178: G = G::from_u64(1099511627776);
-                        let __v_179: G = (__v_178 * __v_74);
-                        let __v_180: G = G::from_u64(281474976710656);
-                        let __v_181: G = (__v_180 * __v_75);
-                        let __v_182: G = G::from_u64(72057594037927936);
-                        let __v_183: G = (__v_182 * __v_76);
-                        let __v_184: G = (__v_181 + __v_183);
-                        let __v_185: G = (__v_179 + __v_184);
-                        let __v_186: G = (__v_177 + __v_185);
-                        let __v_187: G = (__v_175 + __v_186);
-                        let __v_188: G = (__v_173 + __v_187);
-                        let __v_189: G = (__v_171 + __v_188);
-                        let __v_190: G = (__v_69 + __v_189);
-                        if (__v_190 != __v_31) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_190.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
+                        let __v_171: G = G::from_u64(0);
+                        let __v_172: G = G::from_u64(256);
+                        let __v_173: G = (__v_172 * __v_77);
+                        let __v_174: G = G::from_u64(65536);
+                        let __v_175: G = (__v_174 * __v_78);
+                        let __v_176: G = G::from_u64(16777216);
+                        let __v_177: G = (__v_176 * __v_79);
+                        let __v_178: G = G::from_u64(4294967296);
+                        let __v_179: G = (__v_178 * __v_80);
+                        let __v_180: G = G::from_u64(1099511627776);
+                        let __v_181: G = (__v_180 * __v_81);
+                        let __v_182: G = G::from_u64(281474976710656);
+                        let __v_183: G = (__v_182 * __v_82);
+                        let __v_184: G = G::from_u64(72057594037927936);
+                        let __v_185: G = (__v_184 * __v_83);
+                        let __v_186: G = (__v_183 + __v_185);
+                        let __v_187: G = (__v_181 + __v_186);
+                        let __v_188: G = (__v_179 + __v_187);
+                        let __v_189: G = (__v_177 + __v_188);
+                        let __v_190: G = (__v_175 + __v_189);
+                        let __v_191: G = (__v_173 + __v_190);
+                        let __v_192: G = (__v_76 + __v_191);
+                        if (__v_192 != __v_30) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_192.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None });
                         }
-                        let __v_191: G = G::from_u64(1);
-                        let __v_192: G = G::from_u64(1);
-                        let __v_193: G = (__v_192 - __v_86);
-                        let __v_194: G = (__v_82 * __v_193);
-                        let __v_195: G = (__v_191 - __v_194);
-                        let __v_196: G = G::from_u64(1);
-                        if (__v_195 != __v_196) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_195.as_canonical_u64(), rhs: __v_196.as_canonical_u64(), msg: None });
+                        let __v_193: G = G::from_u64(1);
+                        let __v_194: G = G::from_u64(1);
+                        let __v_195: G = (__v_194 - __v_93);
+                        let __v_196: G = (__v_89 * __v_195);
+                        let __v_197: G = (__v_193 - __v_196);
+                        let __v_198: G = G::from_u64(1);
+                        if (__v_197 != __v_198) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_197.as_canonical_u64(), rhs: __v_198.as_canonical_u64(), msg: None });
                         }
-                        let __v_197: G = G::from_u64(0);
-                        let __v_198: G = G::from_u64(256);
-                        let __v_199: G = (__v_198 * __v_88);
-                        let __v_200: G = G::from_u64(65536);
-                        let __v_201: G = (__v_200 * __v_89);
-                        let __v_202: G = G::from_u64(16777216);
-                        let __v_203: G = (__v_202 * __v_90);
-                        let __v_204: G = G::from_u64(4294967296);
-                        let __v_205: G = (__v_204 * __v_91);
-                        let __v_206: G = G::from_u64(1099511627776);
-                        let __v_207: G = (__v_206 * __v_92);
-                        let __v_208: G = G::from_u64(281474976710656);
-                        let __v_209: G = (__v_208 * __v_93);
-                        let __v_210: G = G::from_u64(72057594037927936);
-                        let __v_211: G = (__v_210 * __v_94);
-                        let __v_212: G = (__v_209 + __v_211);
-                        let __v_213: G = (__v_207 + __v_212);
-                        let __v_214: G = (__v_205 + __v_213);
-                        let __v_215: G = (__v_203 + __v_214);
-                        let __v_216: G = (__v_201 + __v_215);
-                        let __v_217: G = (__v_199 + __v_216);
-                        let __v_218: G = (__v_87 + __v_217);
-                        if (__v_218 != __v_32) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_218.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
+                        let __v_199: G = G::from_u64(0);
+                        let __v_200: G = G::from_u64(256);
+                        let __v_201: G = (__v_200 * __v_95);
+                        let __v_202: G = G::from_u64(65536);
+                        let __v_203: G = (__v_202 * __v_96);
+                        let __v_204: G = G::from_u64(16777216);
+                        let __v_205: G = (__v_204 * __v_97);
+                        let __v_206: G = G::from_u64(4294967296);
+                        let __v_207: G = (__v_206 * __v_98);
+                        let __v_208: G = G::from_u64(1099511627776);
+                        let __v_209: G = (__v_208 * __v_99);
+                        let __v_210: G = G::from_u64(281474976710656);
+                        let __v_211: G = (__v_210 * __v_100);
+                        let __v_212: G = G::from_u64(72057594037927936);
+                        let __v_213: G = (__v_212 * __v_101);
+                        let __v_214: G = (__v_211 + __v_213);
+                        let __v_215: G = (__v_209 + __v_214);
+                        let __v_216: G = (__v_207 + __v_215);
+                        let __v_217: G = (__v_205 + __v_216);
+                        let __v_218: G = (__v_203 + __v_217);
+                        let __v_219: G = (__v_201 + __v_218);
+                        let __v_220: G = (__v_94 + __v_219);
+                        if (__v_220 != __v_31) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_220.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
                         }
-                        let __v_219: G = G::from_u64(1);
-                        let __v_220: G = G::from_u64(1);
-                        let __v_221: G = (__v_220 - __v_104);
-                        let __v_222: G = (__v_100 * __v_221);
-                        let __v_223: G = (__v_219 - __v_222);
-                        let __v_224: G = G::from_u64(1);
-                        if (__v_223 != __v_224) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_223.as_canonical_u64(), rhs: __v_224.as_canonical_u64(), msg: None });
-                        }
-                        let __v_225: G = G::from_u64(1);
+                        let __v_221: G = G::from_u64(1);
+                        let __v_222: G = G::from_u64(1);
+                        let __v_223: G = (__v_222 - __v_111);
+                        let __v_224: G = (__v_107 * __v_223);
+                        let __v_225: G = (__v_221 - __v_224);
                         let __v_226: G = G::from_u64(1);
-                        let __v_227: G = { let __values: [G; 10] = [__v_225, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_228: G = { let __values: [G; 10] = [__v_197, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_227]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_229: G = { let __values: [G; 10] = [__v_169, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_228]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_230: G = { let __values: [G; 10] = [__v_141, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_229]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_231: G = { let __values: [G; 10] = [__v_113, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_230]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_232: G = G::from_u64(1);
-                        let __v_233: G = G::from_u64(1);
-                        let __v_234: G = { let __values: [G; 3] = [__v_232, __v_233, __v_233]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_235: G = { let __values: [G; 3] = [__v_112, __v_231, __v_234]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_236: G = G::from_u64(0);
-                        let __v_237: G = G::from_u64(1);
-                        let __v_238: G = G::from_u64(1);
-                        let __v_239: G = { let __values: [G; 3] = [__v_237, __v_238, __v_238]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_240: G = { let __values: [G; 3] = [__v_236, __v_25, __v_239]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_19, __v_235, __v_240, __v_23, __v_12, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { 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_241: G = __r_arr[0];
-                        let __v_242: G = G::from_u64(1);
-                        if (__v_241 != __v_242) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: None });
+                        if (__v_225 != __v_226) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_225.as_canonical_u64(), rhs: __v_226.as_canonical_u64(), msg: None });
                         }
-                        let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_107, __v_108, __v_17, __v_20, __v_13, __v_23, __v_25, __v_109, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { 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_243: G = __r_arr[0];
-                        let __v_244: G = __r_arr[1];
-                        let __ret: [G; OUT_140] = [__v_243, __v_244];
-                        if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __v_227: G = G::from_u64(1);
+                        let __v_228: G = G::from_u64(1);
+                        let __v_229: G = { let __values: [G; 10] = [__v_227, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_230: G = { let __values: [G; 10] = [__v_199, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_229]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_231: G = { let __values: [G; 10] = [__v_171, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_230]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_232: G = { let __values: [G; 10] = [__v_143, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_231]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_233: G = { let __values: [G; 10] = [__v_115, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_232]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_234: G = { let __values: [G; 3] = [__v_114, __v_233, __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_145] = [__v_37, __v_38, __v_234];
+                        if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                       _ => {
-                        return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
+                        return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
                       },
                     }
                   },
                 }
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
           },
         }
       },
@@ -13266,15 +13769,15 @@ fn aiur_fn_140(
   })
 }
 
-const INPUT_SIZE_141: usize = 25;
-const IN_141: usize = 25;
-const OUT_141: usize = 1;
-fn aiur_fn_141(
-  inp: [G; IN_141],
+const INPUT_SIZE_146: usize = 25;
+const IN_146: usize = 25;
+const OUT_146: usize = 1;
+fn aiur_fn_146(
+  inp: [G; IN_146],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_141], 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];
@@ -13303,96 +13806,96 @@ fn aiur_fn_141(
     let __v_24: G = inp[24];
     match __v_1.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { 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_129] = { let __args: [G; IN_129] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(0);
-        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_15, __v_19, __v_18, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_15, __v_19, __v_18, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { 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_27: G = __r_arr[0];
         let __v_28: G = G::from_u64(0);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
-        let __v_30: G = __r_arr[1];
         match __v_29.as_canonical_u64() {
           _ => {
-            let __v_31: G = G::from_u64(0);
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_25, __v_0, __v_20, __v_19, __v_31, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
-            let __v_32: G = __r_arr[0];
-            let __v_33: G = G::from_u64(1);
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-            let __v_34: G = __r_arr[0];
-            let __v_35: G = __r_arr[1];
-            match __v_34.as_canonical_u64() {
+            let __v_30: G = G::from_u64(0);
+            let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_25, __v_0, __v_20, __v_19, __v_30, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { 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_31: G = __r_arr[0];
+            let __v_32: G = G::from_u64(1);
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+            let __v_33: G = __r_arr[0];
+            match __v_33.as_canonical_u64() {
               _ => {
-                let __v_36: G = G::from_u64(0);
-                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_32, __v_0, __v_20, __v_19, __v_36, __v_18, __v_15, __v_16, __v_17, __v_34, __v_6, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
+                let __v_34: G = G::from_u64(0);
+                let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_31, __v_0, __v_20, __v_19, __v_34, __v_18, __v_15, __v_16, __v_17, __v_33, __v_6, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { 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_35: G = __r_arr[0];
+                let __v_36: G = G::from_u64(2);
+                let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
                 let __v_37: G = __r_arr[0];
-                let __v_38: G = G::from_u64(2);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                let __v_39: G = __r_arr[0];
-                let __v_40: G = __r_arr[1];
-                match __v_39.as_canonical_u64() {
+                match __v_37.as_canonical_u64() {
                   _ => {
-                    let __v_41: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_37, __v_0, __v_20, __v_19, __v_41, __v_18, __v_15, __v_16, __v_17, __v_39, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
-                    let __v_42: G = __r_arr[0];
-                    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_42, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { 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_43: G = __r_arr[0];
-                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_43, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_44: G = __r_arr[0];
-                    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_43.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
-                    let __v_45: G = __loaded[0];
-                    let __v_46: G = __loaded[1];
-                    let __v_47: G = __loaded[2];
-                    let __v_48: G = __loaded[3];
-                    let __v_49: G = __loaded[4];
-                    let __v_50: G = __loaded[5];
-                    let __v_51: G = __loaded[6];
-                    match __v_45.as_canonical_u64() {
+                    let __v_38: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_35, __v_0, __v_20, __v_19, __v_38, __v_18, __v_15, __v_16, __v_17, __v_37, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { 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_39: G = __r_arr[0];
+                    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_39, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { 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_40: G = __r_arr[0];
+                    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_40, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+                    let __v_41: G = __r_arr[0];
+                    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_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: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+                    let __v_42: G = __loaded[0];
+                    let __v_43: G = __loaded[1];
+                    let __v_44: G = __loaded[2];
+                    let __v_45: G = __loaded[3];
+                    let __v_46: G = __loaded[4];
+                    let __v_47: G = __loaded[5];
+                    let __v_48: G = __loaded[6];
+                    match __v_42.as_canonical_u64() {
                       0u64 => {
-                        match __v_46.as_canonical_u64() {
+                        match __v_43.as_canonical_u64() {
                           _ => {
-                            let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_49, __v_50, __v_21, __v_22, __v_2, __v_0, __v_20, __v_51, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { 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_52: G = __r_arr[0];
-                            let __v_53: G = __r_arr[1];
-                            let __v_54: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_23, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_46, __v_47, __v_21, __v_22, __v_2, __v_0, __v_20, __v_48, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
+                            let __v_49: G = __r_arr[0];
+                            let __v_50: G = __r_arr[1];
+                            let __v_51: G = __r_arr[2];
+                            let __v_52: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_23, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+                            let __v_53: G = __r_arr[0];
+                            let __v_54: G = __r_arr[1];
+                            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
                             let __v_55: G = __r_arr[0];
-                            let __v_56: G = __r_arr[1];
-                            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
-                            let __v_57: G = __r_arr[0];
-                            let __v_58: G = (__v_57 - __v_24);
-                            let __v_59: G = G::from_bool((__v_58 == G::ZERO));
-                            let __v_60: G = G::from_u64(1);
-                            if (__v_59 != __v_60) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
+                            let __v_56: G = (__v_55 - __v_24);
+                            let __v_57: G = G::from_bool((__v_56 == G::ZERO));
+                            let __v_58: G = G::from_u64(1);
+                            if (__v_57 != __v_58) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: None });
                             }
-                            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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+                            let __v_59: G = __r_arr[0];
+                            let __v_60: G = G::from_u64(3);
+                            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
                             let __v_61: G = __r_arr[0];
-                            let __v_62: G = G::from_u64(3);
-                            let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } };
-                            let __v_63: G = __r_arr[0];
-                            let __v_64: G = (__v_62 + __v_63);
-                            let __v_65: G = (__v_61 - __v_64);
-                            let __v_66: G = G::from_bool((__v_65 == G::ZERO));
-                            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(), msg: None });
+                            let __v_62: G = (__v_60 + __v_61);
+                            let __v_63: G = (__v_59 - __v_62);
+                            let __v_64: G = G::from_bool((__v_63 == G::ZERO));
+                            let __v_65: G = G::from_u64(1);
+                            if (__v_64 != __v_65) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None });
                             }
-                            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                            let __v_68: G = __r_arr[0];
-                            let __v_69: G = (__v_68 - __v_18);
-                            let __v_70: G = G::from_bool((__v_69 == G::ZERO));
-                            let __v_71: G = G::from_u64(1);
-                            if (__v_70 != __v_71) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None });
+                            let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+                            let __v_66: G = __r_arr[0];
+                            let __v_67: G = (__v_66 - __v_18);
+                            let __v_68: G = G::from_bool((__v_67 == G::ZERO));
+                            let __v_69: G = G::from_u64(1);
+                            if (__v_68 != __v_69) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: None });
                             }
-                            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_10, __v_29, __v_27, __v_0, __v_30, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { 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_72: G = __r_arr[0];
+                            let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+                            let __v_70: G = __r_arr[0];
+                            let __v_71: G = (__v_70 - __v_18);
+                            let __v_72: G = G::from_bool((__v_71 == G::ZERO));
                             let __v_73: G = G::from_u64(1);
                             if (__v_72 != __v_73) {
                               return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None });
                             }
-                            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
                             let __v_74: G = __r_arr[0];
                             let __v_75: G = (__v_74 - __v_18);
                             let __v_76: G = G::from_bool((__v_75 == G::ZERO));
@@ -13400,50 +13903,29 @@ fn aiur_fn_141(
                             if (__v_76 != __v_77) {
                               return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
                             }
-                            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_11, __v_34, __v_27, __v_0, __v_35, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { 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_78: G = __r_arr[0];
-                            let __v_79: G = G::from_u64(1);
-                            if (__v_78 != __v_79) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_79.as_canonical_u64(), msg: None });
+                            let __v_78: G = (__v_43 - __v_20);
+                            let __v_79: G = G::from_bool((__v_78 == G::ZERO));
+                            let __v_80: G = G::from_u64(1);
+                            if (__v_79 != __v_80) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_80.as_canonical_u64(), msg: None });
                             }
-                            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                            let __v_80: G = __r_arr[0];
-                            let __v_81: G = (__v_80 - __v_18);
+                            let __v_81: G = (__v_53 - __v_49);
                             let __v_82: G = G::from_bool((__v_81 == G::ZERO));
-                            let __v_83: G = G::from_u64(1);
-                            if (__v_82 != __v_83) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_83.as_canonical_u64(), msg: None });
-                            }
-                            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_12, __v_39, __v_27, __v_0, __v_40, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { 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_84: G = __r_arr[0];
-                            let __v_85: G = G::from_u64(1);
-                            if (__v_84 != __v_85) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_85.as_canonical_u64(), msg: None });
-                            }
-                            let __v_86: G = (__v_46 - __v_20);
-                            let __v_87: G = G::from_bool((__v_86 == G::ZERO));
-                            let __v_88: G = G::from_u64(1);
-                            if (__v_87 != __v_88) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None });
-                            }
-                            let __v_89: G = (__v_55 - __v_52);
-                            let __v_90: G = G::from_bool((__v_89 == G::ZERO));
-                            let __v_91: G = (__v_56 - __v_53);
-                            let __v_92: G = G::from_bool((__v_91 == G::ZERO));
-                            let __v_93: G = (__v_90 * __v_92);
-                            let __v_94: G = G::from_u64(1);
-                            if (__v_93 != __v_94) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_94.as_canonical_u64(), msg: None });
+                            let __v_83: G = (__v_54 - __v_50);
+                            let __v_84: G = G::from_bool((__v_83 == G::ZERO));
+                            let __v_85: G = (__v_82 * __v_84);
+                            let __v_86: G = G::from_u64(1);
+                            if (__v_85 != __v_86) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_86.as_canonical_u64(), msg: None });
                             }
-                            let __v_95: G = G::from_u64(1);
-                            let __ret: [G; OUT_141] = [__v_95];
-                            if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_146] = [__v_51];
+                            if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
-                        return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64()));
+                        return Err(ExecError::MatchNoCase(__v_42.as_canonical_u64()));
                       },
                     }
                   },
@@ -13457,15 +13939,462 @@ fn aiur_fn_141(
   })
 }
 
-const INPUT_SIZE_142: usize = 25;
-const IN_142: usize = 25;
-const OUT_142: usize = 1;
-fn aiur_fn_142(
-  inp: [G; IN_142],
+const INPUT_SIZE_147: usize = 25;
+const IN_147: usize = 25;
+const OUT_147: usize = 1;
+fn aiur_fn_147(
+  inp: [G; IN_147],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_147], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_25: G = __loaded[0];
+    let __v_26: G = __loaded[1];
+    let __v_27: G = __loaded[2];
+    let __v_28: G = __loaded[3];
+    match __v_25.as_canonical_u64() {
+      1u64 => {
+        let __v_29: G = G::from_u64(1);
+        let __v_30: G = G::from_u64(1);
+        let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_147] = [__v_31];
+        if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+        let __v_29: G = __r_arr[0];
+        let __v_30: G = __r_arr[1];
+        let __v_31: G = __r_arr[2];
+        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+        let __v_32: G = __r_arr[0];
+        let __v_33: G = G::from_u64(0);
+        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+        let __v_34: G = __r_arr[0];
+        let __v_35: G = { let __values: [G; 3] = [__v_33, __v_32, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_147] = [__v_35];
+        if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_148: usize = 4;
+const IN_148: usize = 4;
+const OUT_148: usize = 1;
+fn aiur_fn_148(
+  inp: [G; IN_148],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_148], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_148] = [__v_6];
+        if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __v_6: G = __r_arr[2];
+        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_148] = { let __args: [G; IN_148] = [__v_5, __v_6, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = { let __values: [G; 3] = [__v_7, __v_4, __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_148] = [__v_11];
+        if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_149: usize = 2;
+const IN_149: usize = 2;
+const OUT_149: usize = 1;
+fn aiur_fn_149(
+  inp: [G; IN_149],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_149], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __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_149] = [__v_8];
+        if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_3.as_canonical_u64() {
+          _ => {
+            let __v_6: G = G::from_u64(0);
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
+            let __v_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_149] = [__v_9];
+            if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_150: usize = 2;
+const IN_150: usize = 2;
+const OUT_150: usize = 1;
+fn aiur_fn_150(
+  inp: [G; IN_150],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_150], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __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_150] = [__v_9];
+        if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_3.as_canonical_u64() {
+          _ => {
+            let __v_7: G = G::from_u64(0);
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = { let __values: [G; 4] = [__v_7, __v_3, __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_150] = [__v_10];
+            if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_151: usize = 4;
+const IN_151: usize = 4;
+const OUT_151: usize = 1;
+fn aiur_fn_151(
+  inp: [G; IN_151],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_151], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __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_151] = [__v_6];
+        if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = (__v_2 + __v_7);
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = (__v_3 - __v_9);
+        let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __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_151] = [__v_12];
+        if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_152: usize = 13;
+const IN_152: usize = 13;
+const OUT_152: usize = 1;
+fn aiur_fn_152(
+  inp: [G; IN_152],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_152], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = G::from_u64(0);
+    let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_9, __v_11, __v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { 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_14: G = __r_arr[0];
+    let __v_15: G = G::from_u64(0);
+    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+    let __v_16: G = __r_arr[0];
+    let __v_17: G = __r_arr[1];
+    match __v_16.as_canonical_u64() {
+      _ => {
+        let __v_18: G = G::from_u64(1);
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        match __v_19.as_canonical_u64() {
+          _ => {
+            let __v_21: G = G::from_u64(2);
+            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+            let __v_22: G = __r_arr[0];
+            let __v_23: G = __r_arr[1];
+            match __v_22.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2, __v_16, __v_14, __v_1, __v_17, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+                let __v_24: G = __r_arr[0];
+                let __v_25: G = G::from_u64(1);
+                if (__v_24 != __v_25) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None });
+                }
+                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3, __v_19, __v_14, __v_1, __v_20, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_26: G = __r_arr[0];
+                let __v_27: G = G::from_u64(1);
+                if (__v_26 != __v_27) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None });
+                }
+                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_4, __v_22, __v_14, __v_1, __v_23, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_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(), msg: None });
+                }
+                match __v_6.as_canonical_u64() {
+                  0u64 => {
+                    let __v_30: G = G::from_u64(1);
+                    let __ret: [G; OUT_152] = [__v_30];
+                    if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    return Ok(__ret);
+                  },
+                  1u64 => {
+                    let __v_30: G = G::from_u64(3);
+                    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+                    let __v_31: G = __r_arr[0];
+                    let __v_32: G = __r_arr[1];
+                    match __v_31.as_canonical_u64() {
+                      _ => {
+                        let __v_33: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_9, __v_11, __v_8, __v_10, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { 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_34: G = __r_arr[0];
+                        let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { 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_35: G = __r_arr[0];
+                        let __v_36: G = (__v_12 - __v_35);
+                        let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_1, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
+                        let __v_37: G = __r_arr[0];
+                        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5, __v_31, __v_34, __v_37, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_38: G = __r_arr[0];
+                        let __ret: [G; OUT_152] = [__v_38];
+                        if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_153: usize = 2;
+const IN_153: usize = 2;
+const OUT_153: usize = 1;
+fn aiur_fn_153(
+  inp: [G; IN_153],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_153], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_153] = [__v_0];
+        if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
+        let __v_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_153] = [__v_8];
+        if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_154: usize = 2;
+const IN_154: usize = 2;
+const OUT_154: usize = 1;
+fn aiur_fn_154(
+  inp: [G; IN_154],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_154], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_154] = [__v_7];
+        if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_11: G = { 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 __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __v_13: G = { let __values: [G; 3] = [__v_5, __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_154] = [__v_13];
+        if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_155: usize = 6;
+const IN_155: usize = 6;
+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_142], 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];
@@ -13473,66 +14402,90 @@ fn aiur_fn_142(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_25: G = __loaded[0];
-    let __v_26: G = __loaded[1];
-    let __v_27: G = __loaded[2];
-    let __v_28: G = __loaded[3];
-    match __v_25.as_canonical_u64() {
+    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __v_6: G = __loaded[0];
+    let __v_7: G = __loaded[1];
+    let __v_8: G = __loaded[2];
+    let __v_9: G = __loaded[3];
+    let __v_10: G = __loaded[4];
+    match __v_6.as_canonical_u64() {
       1u64 => {
-        let __v_29: G = G::from_u64(1);
-        let __ret: [G; OUT_142] = [__v_29];
-        if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = G::from_bool((__v_11 == G::ZERO));
+        let __ret: [G; OUT_155] = [__v_12];
+        if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
-        let __v_29: G = __r_arr[0];
-        let __v_30: G = __r_arr[1];
-        let __v_31: G = __r_arr[2];
-        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { 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_32: G = __r_arr[0];
-        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { 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_33: G = __r_arr[0];
-        let __ret: [G; OUT_142] = [__v_33];
-        if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_11: G = __loaded[0];
+        let __v_12: G = __loaded[1];
+        let __v_13: G = __loaded[2];
+        match __v_11.as_canonical_u64() {
+          0u64 => {
+            match __v_7.as_canonical_u64() {
+              _ => {
+                let __v_14: G = G::from_u64(1);
+                let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
+                let __v_15: G = __r_arr[0];
+                let __v_16: G = G::from_u64(1);
+                let __v_17: G = (__v_5 - __v_16);
+                let __v_18: G = G::from_u64(1);
+                if (__v_7 != __v_18) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
+                }
+                let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+                let __v_19: G = __r_arr[0];
+                let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+                let __v_20: G = __r_arr[0];
+                if (__v_19 != __v_20) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None });
+                }
+                let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
+                let __v_21: G = __r_arr[0];
+                let __v_22: G = G::from_u64(0);
+                let __v_23: G = G::from_u64(1);
+                let __v_24: G = G::from_u64(1);
+                let __v_25: G = { let __values: [G; 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 = { let __values: [G; 3] = [__v_22, __v_17, __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_115] = { let __args: [G; IN_115] = [__v_12, __v_21, __v_26, __v_15, __v_9, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { 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_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(), msg: None });
+                }
+                let __v_29: G = G::from_u64(1);
+                let __v_30: G = (__v_4 + __v_29);
+                let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_10, __v_13, __v_2, __v_15, __v_30, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
+                let __v_31: G = __r_arr[0];
+                let __ret: [G; OUT_155] = [__v_31];
+                if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+          },
+        }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_143: usize = 31;
-const IN_143: usize = 31;
-const OUT_143: usize = 1;
-fn aiur_fn_143(
-  inp: [G; IN_143],
+const INPUT_SIZE_156: usize = 32;
+const IN_156: usize = 32;
+const OUT_156: usize = 1;
+fn aiur_fn_156(
+  inp: [G; IN_156],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_143], 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];
@@ -13565,184 +14518,208 @@ fn aiur_fn_143(
     let __v_28: G = inp[28];
     let __v_29: G = inp[29];
     let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
     match __v_6.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-        let __v_31: G = __r_arr[0];
-        let __v_32: G = G::from_u64(1);
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+        let __v_32: G = __r_arr[0];
         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_34: G = G::from_u64(1);
+        let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() {
   0u64 => {
-    break '__mc_0 [__v_34];
+    break '__mc_0 [__v_35];
   },
   1u64 => {
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_5, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-    let __v_35: G = __r_arr[0];
-    break '__mc_0 [__v_35];
+    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_5, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_36: G = __r_arr[0];
+    break '__mc_0 [__v_36];
   },
   _ => {
     return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
   },
 }
  };
-        let __v_35: G = __mc_out___mc_0[0];
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-        let __v_36: G = __r_arr[0];
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+        let __v_36: G = __mc_out___mc_0[0];
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_39: G = __r_arr[0];
-        let __v_40: G = G::from_u64(1);
+        let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
+        let __v_40: G = __r_arr[0];
         let __v_41: G = G::from_u64(1);
-        let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-        let __v_43: G = __r_arr[0];
-        let __v_44: G = __r_arr[1];
-        let __v_45: G = __r_arr[2];
-        let __v_46: G = __r_arr[3];
-        let __v_47: G = __r_arr[4];
-        let __v_48: G = __r_arr[5];
-        let __v_49: G = __r_arr[6];
-        let __v_50: G = __r_arr[7];
-        let __v_51: G = __r_arr[8];
-        let __v_52: G = __r_arr[9];
-        let __v_53: G = __r_arr[10];
-        let __v_54: G = __r_arr[11];
-        let __v_55: G = __r_arr[12];
-        let __v_56: G = __r_arr[13];
-        let __v_57: G = __r_arr[14];
-        let __v_58: G = __r_arr[15];
-        let __v_59: G = __r_arr[16];
-        let __v_60: G = __r_arr[17];
-        let __v_61: G = G::from_u64(256);
-        let __v_62: G = (__v_61 * __v_44);
-        let __v_63: G = G::from_u64(65536);
-        let __v_64: G = (__v_63 * __v_45);
-        let __v_65: G = G::from_u64(16777216);
-        let __v_66: G = (__v_65 * __v_46);
-        let __v_67: G = G::from_u64(4294967296);
-        let __v_68: G = (__v_67 * __v_47);
-        let __v_69: G = G::from_u64(1099511627776);
-        let __v_70: G = (__v_69 * __v_48);
-        let __v_71: G = G::from_u64(281474976710656);
-        let __v_72: G = (__v_71 * __v_49);
-        let __v_73: G = G::from_u64(72057594037927936);
-        let __v_74: G = (__v_73 * __v_50);
-        let __v_75: G = (__v_72 + __v_74);
-        let __v_76: G = (__v_70 + __v_75);
-        let __v_77: G = (__v_68 + __v_76);
-        let __v_78: G = (__v_66 + __v_77);
-        let __v_79: G = (__v_64 + __v_78);
-        let __v_80: G = (__v_62 + __v_79);
-        let __v_81: G = (__v_43 + __v_80);
-        let __v_82: G = G::from_u64(256);
-        let __v_83: G = (__v_82 * __v_52);
-        let __v_84: G = G::from_u64(65536);
-        let __v_85: G = (__v_84 * __v_53);
-        let __v_86: G = G::from_u64(16777216);
-        let __v_87: G = (__v_86 * __v_54);
-        let __v_88: G = G::from_u64(4294967296);
-        let __v_89: G = (__v_88 * __v_55);
-        let __v_90: G = G::from_u64(1099511627776);
-        let __v_91: G = (__v_90 * __v_56);
-        let __v_92: G = G::from_u64(281474976710656);
-        let __v_93: G = (__v_92 * __v_57);
-        let __v_94: G = G::from_u64(72057594037927936);
-        let __v_95: G = (__v_94 * __v_58);
-        let __v_96: G = (__v_93 + __v_95);
-        let __v_97: G = (__v_91 + __v_96);
-        let __v_98: G = (__v_89 + __v_97);
-        let __v_99: G = (__v_87 + __v_98);
-        let __v_100: G = (__v_85 + __v_99);
-        let __v_101: G = (__v_83 + __v_100);
-        let __v_102: G = (__v_51 + __v_101);
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_59, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
-        let __v_103: G = __r_arr[0];
-        let __v_104: G = __r_arr[1];
-        let __v_105: G = G::from_u64(1);
+        let __v_42: G = G::from_u64(1);
+        let __v_43: G = { let __values: [G; 3] = [__v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_40, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+        let __v_44: G = __r_arr[0];
+        let __v_45: G = __r_arr[1];
+        let __v_46: G = __r_arr[2];
+        let __v_47: G = __r_arr[3];
+        let __v_48: G = __r_arr[4];
+        let __v_49: G = __r_arr[5];
+        let __v_50: G = __r_arr[6];
+        let __v_51: G = __r_arr[7];
+        let __v_52: G = __r_arr[8];
+        let __v_53: G = __r_arr[9];
+        let __v_54: G = __r_arr[10];
+        let __v_55: G = __r_arr[11];
+        let __v_56: G = __r_arr[12];
+        let __v_57: G = __r_arr[13];
+        let __v_58: G = __r_arr[14];
+        let __v_59: G = __r_arr[15];
+        let __v_60: G = __r_arr[16];
+        let __v_61: G = __r_arr[17];
+        let __v_62: G = G::from_u64(256);
+        let __v_63: G = (__v_62 * __v_45);
+        let __v_64: G = G::from_u64(65536);
+        let __v_65: G = (__v_64 * __v_46);
+        let __v_66: G = G::from_u64(16777216);
+        let __v_67: G = (__v_66 * __v_47);
+        let __v_68: G = G::from_u64(4294967296);
+        let __v_69: G = (__v_68 * __v_48);
+        let __v_70: G = G::from_u64(1099511627776);
+        let __v_71: G = (__v_70 * __v_49);
+        let __v_72: G = G::from_u64(281474976710656);
+        let __v_73: G = (__v_72 * __v_50);
+        let __v_74: G = G::from_u64(72057594037927936);
+        let __v_75: G = (__v_74 * __v_51);
+        let __v_76: G = (__v_73 + __v_75);
+        let __v_77: G = (__v_71 + __v_76);
+        let __v_78: G = (__v_69 + __v_77);
+        let __v_79: G = (__v_67 + __v_78);
+        let __v_80: G = (__v_65 + __v_79);
+        let __v_81: G = (__v_63 + __v_80);
+        let __v_82: G = (__v_44 + __v_81);
+        let __v_83: G = G::from_u64(256);
+        let __v_84: G = (__v_83 * __v_53);
+        let __v_85: G = G::from_u64(65536);
+        let __v_86: G = (__v_85 * __v_54);
+        let __v_87: G = G::from_u64(16777216);
+        let __v_88: G = (__v_87 * __v_55);
+        let __v_89: G = G::from_u64(4294967296);
+        let __v_90: G = (__v_89 * __v_56);
+        let __v_91: G = G::from_u64(1099511627776);
+        let __v_92: G = (__v_91 * __v_57);
+        let __v_93: G = G::from_u64(281474976710656);
+        let __v_94: G = (__v_93 * __v_58);
+        let __v_95: G = G::from_u64(72057594037927936);
+        let __v_96: G = (__v_95 * __v_59);
+        let __v_97: G = (__v_94 + __v_96);
+        let __v_98: G = (__v_92 + __v_97);
+        let __v_99: G = (__v_90 + __v_98);
+        let __v_100: G = (__v_88 + __v_99);
+        let __v_101: G = (__v_86 + __v_100);
+        let __v_102: G = (__v_84 + __v_101);
+        let __v_103: G = (__v_52 + __v_102);
+        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_60, __v_6, __v_7, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } };
+        let __v_104: G = __r_arr[0];
+        let __v_105: G = __r_arr[1];
         let __v_106: G = G::from_u64(1);
-        let __v_107: G = { let __values: [G; 3] = [__v_105, __v_106, __v_106]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_108: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_104, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+        let __v_107: G = G::from_u64(1);
+        let __v_108: G = { let __values: [G; 3] = [__v_106, __v_107, __v_107]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_10, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
         let __v_109: G = __r_arr[0];
-        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_109, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_105, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
         let __v_110: G = __r_arr[0];
-        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_110, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_110, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
         let __v_111: G = __r_arr[0];
-        let __v_112: G = __r_arr[1];
-        let __v_113: G = (__v_31 + __v_27);
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
-        let __v_114: G = __r_arr[0];
-        let __v_115: G = (__v_114 - __v_31);
-        let __v_116: G = G::from_bool((__v_115 == G::ZERO));
-        let __v_117: G = G::from_u64(1);
-        if (__v_116 != __v_117) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_116.as_canonical_u64(), rhs: __v_117.as_canonical_u64(), msg: None });
-        }
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_111, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_112: G = __r_arr[0];
+        let __v_113: G = __r_arr[1];
+        let __v_114: G = (__v_32 + __v_28);
+        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_112, __v_113, __v_29, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+        let __v_115: G = __r_arr[0];
+        let __v_116: G = G::from_u64(0);
+        let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_8, __v_9, __v_116, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
+        let __v_117: G = __r_arr[0];
+        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_112, __v_113, __v_117, __v_82, __v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_114, __v_104, __v_6, __v_10, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
         let __v_118: G = __r_arr[0];
-        let __v_119: G = (__v_118 - __v_28);
-        let __v_120: G = G::from_bool((__v_119 == G::ZERO));
-        let __v_121: G = G::from_u64(1);
-        if (__v_120 != __v_121) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_120.as_canonical_u64(), rhs: __v_121.as_canonical_u64(), msg: None });
-        }
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-        let __v_122: G = __r_arr[0];
-        let __v_123: G = G::from_u64(1);
-        if (__v_122 != __v_123) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_122.as_canonical_u64(), rhs: __v_123.as_canonical_u64(), msg: None });
+        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+        let __v_119: G = __r_arr[0];
+        let __v_120: G = (__v_119 - __v_32);
+        let __v_121: G = G::from_bool((__v_120 == G::ZERO));
+        let __v_122: G = G::from_u64(1);
+        if (__v_121 != __v_122) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_121.as_canonical_u64(), rhs: __v_122.as_canonical_u64(), msg: None });
         }
-        let __v_124: G = G::from_u64(33);
-        let __v_125: G = { let __a_val = __v_113.as_canonical_u64(); let __b_val = __v_124.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-        let __v_126: G = G::from_u64(1);
-        if (__v_125 != __v_126) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_126.as_canonical_u64(), msg: None });
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+        let __v_123: G = __r_arr[0];
+        let __v_124: G = G::from_u64(3);
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __v_125: G = __r_arr[0];
+        let __v_126: G = (__v_124 + __v_125);
+        if (__v_123 != __v_126) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_126.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_111, __v_112, __v_8, __v_81, __v_102, __v_1, __v_2, __v_3, __v_4, __v_5, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_113, __v_103, __v_6, __v_9, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { 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_216] = { let __args: [G; IN_216] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
         let __v_127: G = __r_arr[0];
-        let __ret: [G; OUT_143] = [__v_127];
-        if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_128: G = (__v_127 - __v_32);
+        let __v_129: G = G::from_bool((__v_128 == G::ZERO));
+        let __v_130: G = G::from_u64(1);
+        if (__v_129 != __v_130) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_129.as_canonical_u64(), rhs: __v_130.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+        let __v_131: G = __r_arr[0];
+        let __v_132: G = G::from_u64(1);
+        if (__v_131 != __v_132) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_131.as_canonical_u64(), rhs: __v_132.as_canonical_u64(), msg: None });
+        }
+        let __v_133: G = G::from_u64(33);
+        let __v_134: G = { let __a_val = __v_114.as_canonical_u64(); let __b_val = __v_133.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+        let __v_135: G = G::from_u64(1);
+        if (__v_134 != __v_135) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_134.as_canonical_u64(), rhs: __v_135.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_8, __v_115, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+        let __v_136: G = __r_arr[0];
+        let __v_137: G = G::from_u64(1);
+        if (__v_136 != __v_137) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_137.as_canonical_u64(), msg: None });
+        }
+        let __v_138: G = G::from_u64(0);
+        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_9, __v_6, __v_118, __v_115, __v_138, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
+        let __v_139: G = __r_arr[0];
+        let __ret: [G; OUT_156] = [__v_139];
+        if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_144: usize = 2;
-const IN_144: usize = 2;
-const OUT_144: usize = 1;
-fn aiur_fn_144(
-  inp: [G; IN_144],
+const INPUT_SIZE_157: usize = 2;
+const IN_157: usize = 2;
+const OUT_157: usize = 1;
+fn aiur_fn_157(
+  inp: [G; IN_157],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_144], ExecError> {
+) -> Result<[G; OUT_157], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_bool((__v_0 == G::ZERO));
     let __v_3: G = G::from_bool((__v_1 == G::ZERO));
     let __v_4: G = (__v_2 * __v_3);
-    let __ret: [G; OUT_144] = [__v_4];
-    if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_157] = [__v_4];
+    if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_145: usize = 1;
-const IN_145: usize = 1;
-const OUT_145: usize = 1;
-fn aiur_fn_145(
-  inp: [G; IN_145],
+const INPUT_SIZE_158: usize = 1;
+const IN_158: usize = 1;
+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_145], ExecError> {
+) -> Result<[G; OUT_158], 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 };
@@ -13753,8 +14730,8 @@ fn aiur_fn_145(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_145] = [__v_5];
-        if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_158] = [__v_5];
+        if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -13768,15 +14745,15 @@ fn aiur_fn_145(
             let __v_9: G = G::from_bool((__v_2 == G::ZERO));
             let __v_10: G = G::from_bool((__v_3 == G::ZERO));
             let __v_11: G = (__v_9 * __v_10);
-            let __ret: [G; OUT_145] = [__v_11];
-            if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_158] = [__v_11];
+            if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_145] = [__v_9];
-            if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_158] = [__v_9];
+            if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -13788,15 +14765,15 @@ fn aiur_fn_145(
   })
 }
 
-const INPUT_SIZE_146: usize = 9;
-const IN_146: usize = 9;
-const OUT_146: usize = 1;
-fn aiur_fn_146(
-  inp: [G; IN_146],
+const INPUT_SIZE_159: usize = 9;
+const IN_159: usize = 9;
+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_146], 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];
@@ -13823,21 +14800,21 @@ fn aiur_fn_146(
     let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_146] = [__v_24];
-    if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_159] = [__v_24];
+    if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_147: usize = 33;
-const IN_147: usize = 33;
-const OUT_147: usize = 1;
-fn aiur_fn_147(
-  inp: [G; IN_147],
+const INPUT_SIZE_160: usize = 33;
+const IN_160: usize = 33;
+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_147], 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];
@@ -13872,29 +14849,29 @@ fn aiur_fn_147(
     let __v_30: G = inp[30];
     let __v_31: G = inp[31];
     let __v_32: G = inp[32];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__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[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__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[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_34: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_35: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_36: G = __r_arr[0];
-    let __ret: [G; OUT_147] = [__v_36];
-    if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_160] = [__v_36];
+    if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_148: usize = 2;
-const IN_148: usize = 2;
-const OUT_148: usize = 1;
-fn aiur_fn_148(
-  inp: [G; IN_148],
+const INPUT_SIZE_161: usize = 2;
+const IN_161: usize = 2;
+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_148], 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];
@@ -13904,8 +14881,8 @@ fn aiur_fn_148(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_148] = [__v_1];
-        if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_161] = [__v_1];
+        if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -13942,18 +14919,18 @@ fn aiur_fn_148(
         let __v_34: G = __loaded[29];
         let __v_35: G = __loaded[30];
         let __v_36: G = __loaded[31];
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__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[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__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[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
         let __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
         let __v_39: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
         let __v_40: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
         let __v_41: G = __r_arr[0];
-        let __ret: [G; OUT_148] = [__v_41];
-        if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_161] = [__v_41];
+        if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -13963,15 +14940,15 @@ fn aiur_fn_148(
   })
 }
 
-const INPUT_SIZE_149: usize = 2;
-const IN_149: usize = 2;
-const OUT_149: usize = 1;
-fn aiur_fn_149(
-  inp: [G; IN_149],
+const INPUT_SIZE_162: usize = 2;
+const IN_162: usize = 2;
+const OUT_162: usize = 1;
+fn aiur_fn_162(
+  inp: [G; IN_162],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_149], 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];
@@ -13981,8 +14958,8 @@ fn aiur_fn_149(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_149] = [__v_1];
-        if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_162] = [__v_1];
+        if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -13993,12 +14970,12 @@ fn aiur_fn_149(
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_149] = [__v_13];
-        if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_162] = [__v_13];
+        if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -14008,15 +14985,15 @@ fn aiur_fn_149(
   })
 }
 
-const INPUT_SIZE_150: usize = 2;
-const IN_150: usize = 2;
-const OUT_150: usize = 10;
-fn aiur_fn_150(
-  inp: [G; IN_150],
+const INPUT_SIZE_163: usize = 2;
+const IN_163: usize = 2;
+const OUT_163: usize = 10;
+fn aiur_fn_163(
+  inp: [G; IN_163],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_150], 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];
@@ -14133,7 +15110,7 @@ fn aiur_fn_150(
         let __v_99: G = G::from_u64(1);
         let __v_100: G = G::from_u64(1);
         let __v_101: G = { let __values: [G; 3] = [__v_99, __v_100, __v_100]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_98, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_98, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_102: 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_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_103: G = __loaded[0];
@@ -14183,8 +15160,8 @@ fn aiur_fn_150(
                                     let __v_126: G = __loaded[2];
                                     match __v_124.as_canonical_u64() {
                                       0u64 => {
-                                        let __ret: [G; OUT_150] = [__v_104, __v_107, __v_110, __v_113, __v_116, __v_119, __v_122, __v_125, __v_98, __v_126];
-                                        if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        let __ret: [G; OUT_163] = [__v_104, __v_107, __v_110, __v_113, __v_116, __v_119, __v_122, __v_125, __v_98, __v_126];
+                                        if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -14270,8 +15247,8 @@ fn aiur_fn_150(
                                 let __v_25: G = __loaded[2];
                                 match __v_23.as_canonical_u64() {
                                   0u64 => {
-                                    let __ret: [G; OUT_150] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25];
-                                    if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_163] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25];
+                                    if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -14316,19 +15293,19 @@ fn aiur_fn_150(
   })
 }
 
-const INPUT_SIZE_151: usize = 2;
-const IN_151: usize = 2;
-const OUT_151: usize = 10;
-fn aiur_fn_151(
-  inp: [G; IN_151],
+const INPUT_SIZE_164: usize = 2;
+const IN_164: usize = 2;
+const OUT_164: usize = 10;
+fn aiur_fn_164(
+  inp: [G; IN_164],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_151], ExecError> {
+) -> Result<[G; OUT_164], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -14356,12 +15333,12 @@ fn aiur_fn_151(
     let __v_26: G = (__v_22 - __v_25);
     match __v_26.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_151] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
-        if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_164] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
+        if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
         let __v_28: G = __r_arr[1];
         let __v_29: G = __r_arr[2];
@@ -14372,27 +15349,27 @@ fn aiur_fn_151(
         let __v_34: G = __r_arr[7];
         let __v_35: G = __r_arr[8];
         let __v_36: G = __r_arr[9];
-        let __ret: [G; OUT_151] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
-        if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_164] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+        if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_152: usize = 2;
-const IN_152: usize = 2;
-const OUT_152: usize = 18;
-fn aiur_fn_152(
-  inp: [G; IN_152],
+const INPUT_SIZE_165: usize = 2;
+const IN_165: usize = 2;
+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_152], ExecError> {
+) -> Result<[G; OUT_165], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -14403,7 +15380,7 @@ fn aiur_fn_152(
     let __v_9: G = __r_arr[7];
     let __v_10: G = __r_arr[8];
     let __v_11: G = __r_arr[9];
-    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
     let __v_14: G = __r_arr[2];
@@ -14414,21 +15391,21 @@ fn aiur_fn_152(
     let __v_19: G = __r_arr[7];
     let __v_20: G = __r_arr[8];
     let __v_21: G = __r_arr[9];
-    let __ret: [G; OUT_152] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-    if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_165] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+    if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_153: usize = 2;
-const IN_153: usize = 2;
-const OUT_153: usize = 1;
-fn aiur_fn_153(
-  inp: [G; IN_153],
+const INPUT_SIZE_166: usize = 2;
+const IN_166: usize = 2;
+const OUT_166: usize = 1;
+fn aiur_fn_166(
+  inp: [G; IN_166],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_153], 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];
@@ -14437,8 +15414,8 @@ fn aiur_fn_153(
         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_153] = [__v_4];
-        if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_166] = [__v_4];
+        if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -14451,11 +15428,11 @@ fn aiur_fn_153(
             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_153] = { let __args: [G; IN_153] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
             let __v_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_153] = [__v_9];
-            if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_166] = [__v_9];
+            if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -14467,20 +15444,20 @@ fn aiur_fn_153(
   })
 }
 
-const INPUT_SIZE_154: usize = 3;
-const IN_154: usize = 3;
-const OUT_154: usize = 3;
-fn aiur_fn_154(
-  inp: [G; IN_154],
+const INPUT_SIZE_167: usize = 3;
+const IN_167: usize = 3;
+const OUT_167: usize = 3;
+fn aiur_fn_167(
+  inp: [G; IN_167],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_154], 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];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -14530,31 +15507,31 @@ fn aiur_fn_154(
     let __v_45: G = G::from_u64(1);
     let __v_46: G = G::from_u64(1);
     let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_48: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_49: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_50: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_51: G = __r_arr[0];
-    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_51, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_51, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
     let __v_52: G = __r_arr[0];
-    let __ret: [G; OUT_154] = [__v_52, __v_11, __v_12];
-    if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_167] = [__v_52, __v_11, __v_12];
+    if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_155: usize = 9;
-const IN_155: usize = 9;
-const OUT_155: usize = 1;
-fn aiur_fn_155(
-  inp: [G; IN_155],
+const INPUT_SIZE_168: usize = 9;
+const IN_168: usize = 9;
+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_155], 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];
@@ -14568,50 +15545,50 @@ fn aiur_fn_155(
     let __v_9: G = G::from_u64(1);
     let __v_10: G = G::from_u64(1);
     let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
-    let __ret: [G; OUT_155] = [__v_13];
-    if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_168] = [__v_13];
+    if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_156: usize = 2;
-const IN_156: usize = 2;
-const OUT_156: usize = 1;
-fn aiur_fn_156(
-  inp: [G; IN_156],
+const INPUT_SIZE_169: usize = 2;
+const IN_169: usize = 2;
+const OUT_169: usize = 1;
+fn aiur_fn_169(
+  inp: [G; IN_169],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_156], ExecError> {
+) -> Result<[G; OUT_169], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = 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_148] = { let __args: [G; IN_148] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_156] = [__v_6];
-    if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_169] = [__v_6];
+    if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_157: usize = 1;
-const IN_157: usize = 1;
-const OUT_157: usize = 1;
-fn aiur_fn_157(
-  inp: [G; IN_157],
+const INPUT_SIZE_170: usize = 1;
+const IN_170: usize = 1;
+const OUT_170: usize = 1;
+fn aiur_fn_170(
+  inp: [G; IN_170],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_157], ExecError> {
+) -> Result<[G; OUT_170], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -14656,21 +15633,21 @@ fn aiur_fn_157(
     let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_157] = [__v_42];
-    if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_170] = [__v_42];
+    if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_158: usize = 2;
-const IN_158: usize = 2;
-const OUT_158: usize = 1;
-fn aiur_fn_158(
-  inp: [G; IN_158],
+const INPUT_SIZE_171: usize = 2;
+const IN_171: usize = 2;
+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_158], 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];
@@ -14687,17 +15664,17 @@ fn aiur_fn_158(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_158] = [__v_1];
-        if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_171] = [__v_1];
+        if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__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[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__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[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_158] = [__v_13];
-        if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_171] = [__v_13];
+        if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -14707,15 +15684,15 @@ fn aiur_fn_158(
   })
 }
 
-const INPUT_SIZE_159: usize = 2;
-const IN_159: usize = 2;
-const OUT_159: usize = 1;
-fn aiur_fn_159(
-  inp: [G; IN_159],
+const INPUT_SIZE_172: usize = 2;
+const IN_172: usize = 2;
+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_159], 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];
@@ -14724,13 +15701,13 @@ fn aiur_fn_159(
         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_159] = [__v_4];
-        if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_172] = [__v_4];
+        if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
-        let __ret: [G; OUT_159] = [__v_1];
-        if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_172] = [__v_1];
+        if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -14740,15 +15717,15 @@ fn aiur_fn_159(
   })
 }
 
-const INPUT_SIZE_160: usize = 9;
-const IN_160: usize = 9;
-const OUT_160: usize = 9;
-fn aiur_fn_160(
-  inp: [G; IN_160],
+const INPUT_SIZE_173: usize = 9;
+const IN_173: usize = 9;
+const OUT_173: usize = 9;
+fn aiur_fn_173(
+  inp: [G; IN_173],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_160], 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];
@@ -14759,15 +15736,15 @@ fn aiur_fn_160(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     let __v_14: G = G::from_u64(0);
     let __v_15: G = G::from_u64(109);
@@ -14814,7 +15791,7 @@ fn aiur_fn_160(
     let __v_56: G = G::from_u64(1);
     let __v_57: G = G::from_u64(1);
     let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_55, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_55, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
     let __v_59: G = __r_arr[0];
     let __v_60: G = __r_arr[1];
     let __v_61: G = __r_arr[2];
@@ -14836,16 +15813,16 @@ fn aiur_fn_160(
     let __v_77: G = G::from_u64(1);
     let __v_78: G = G::from_u64(1);
     let __v_79: G = { let __values: [G; 3] = [__v_77, __v_78, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_80: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_81: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_75, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_75, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
     let __v_82: G = __r_arr[0];
     let __v_83: G = G::from_u64(1);
     let __v_84: G = G::from_u64(1);
     let __v_85: G = { let __values: [G; 3] = [__v_83, __v_84, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_82, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_82, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
     let __v_86: G = __r_arr[0];
     let __v_87: G = __r_arr[1];
     let __v_88: G = __r_arr[2];
@@ -14867,25 +15844,25 @@ fn aiur_fn_160(
     let __v_104: G = G::from_u64(1);
     let __v_105: G = G::from_u64(1);
     let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_107: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_108: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_102, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_102, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
     let __v_109: G = __r_arr[0];
-    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_109, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_109, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
     let __v_110: G = __r_arr[0];
     let __v_111: G = G::from_u64(1);
     let __v_112: G = G::from_u64(1);
     let __v_113: G = { let __values: [G; 3] = [__v_111, __v_112, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_8, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_121] = { let __args: [G; IN_121] = [__v_8, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
     let __v_114: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_110, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_110, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
     let __v_115: G = __r_arr[0];
     let __v_116: G = G::from_u64(1);
     let __v_117: G = G::from_u64(1);
     let __v_118: G = { let __values: [G; 3] = [__v_116, __v_117, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_115, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_115, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
     let __v_119: G = __r_arr[0];
     let __v_120: G = __r_arr[1];
     let __v_121: G = __r_arr[2];
@@ -14904,12 +15881,12 @@ fn aiur_fn_160(
     let __v_134: G = __r_arr[15];
     let __v_135: G = __r_arr[16];
     let __v_136: G = __r_arr[17];
-    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_135, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_135, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
     let __v_137: G = __r_arr[0];
     let __v_138: G = G::from_u64(1);
     let __v_139: G = G::from_u64(1);
     let __v_140: G = { let __values: [G; 3] = [__v_138, __v_139, __v_139]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_137, __v_140]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_137, __v_140]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
     let __v_141: G = __r_arr[0];
     let __v_142: G = __r_arr[1];
     let __v_143: G = __r_arr[2];
@@ -15096,29 +16073,29 @@ fn aiur_fn_160(
     let __v_324: G = (__v_309 + __v_323);
     let __v_325: G = (__v_307 + __v_324);
     let __v_326: G = (__v_149 + __v_325);
-    let __ret: [G; OUT_160] = [__v_179, __v_200, __v_221, __v_242, __v_263, __v_284, __v_305, __v_326, __v_157];
-    if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_173] = [__v_179, __v_200, __v_221, __v_242, __v_263, __v_284, __v_305, __v_326, __v_157];
+    if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_161: usize = 3;
-const IN_161: usize = 3;
-const OUT_161: usize = 2;
-fn aiur_fn_161(
-  inp: [G; IN_161],
+const INPUT_SIZE_174: usize = 3;
+const IN_174: usize = 3;
+const OUT_174: usize = 2;
+fn aiur_fn_174(
+  inp: [G; IN_174],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_161], 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];
     let __v_2: G = inp[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_161] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_174] = [__v_0, __v_1];
+        if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -15132,135 +16109,135 @@ fn aiur_fn_161(
         let __v_10: G = (__v_8 + __v_9);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = (__v_2 - __v_11);
-        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_161] = [__v_13, __v_14];
-        if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_174] = [__v_13, __v_14];
+        if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_162: usize = 1;
-const IN_162: usize = 1;
-const OUT_162: usize = 1;
-fn aiur_fn_162(
-  inp: [G; IN_162],
+const INPUT_SIZE_175: usize = 1;
+const IN_175: usize = 1;
+const OUT_175: usize = 1;
+fn aiur_fn_175(
+  inp: [G; IN_175],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_162], ExecError> {
+) -> Result<[G; OUT_175], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_162] = [__v_1];
-        if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_175] = [__v_1];
+        if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       32u64 => {
         let __v_1: G = G::from_u64(1753635133440165772);
-        let __ret: [G; OUT_162] = [__v_1];
-        if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_175] = [__v_1];
+        if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_1: G = G::from_u64(1);
         let __v_2: G = (__v_0 + __v_1);
-        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = (__v_3 * __v_3);
-        let __ret: [G; OUT_162] = [__v_4];
-        if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_175] = [__v_4];
+        if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_163: usize = 3;
-const IN_163: usize = 3;
-const OUT_163: usize = 2;
-fn aiur_fn_163(
-  inp: [G; IN_163],
+const INPUT_SIZE_176: usize = 3;
+const IN_176: usize = 3;
+const OUT_176: usize = 2;
+fn aiur_fn_176(
+  inp: [G; IN_176],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_163], 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];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = G::from_u64(1);
     let __v_6: G = G::from_u64(0);
     let __v_7: G = (__v_3 - __v_5);
     let __v_8: G = (__v_4 - __v_6);
-    let __ret: [G; OUT_163] = [__v_7, __v_8];
-    if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_176] = [__v_7, __v_8];
+    if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_164: usize = 1;
-const IN_164: usize = 1;
-const OUT_164: usize = 1;
-fn aiur_fn_164(
-  inp: [G; IN_164],
+const INPUT_SIZE_177: usize = 1;
+const IN_177: usize = 1;
+const OUT_177: usize = 1;
+fn aiur_fn_177(
+  inp: [G; IN_177],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_164], ExecError> {
+) -> Result<[G; OUT_177], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_164] = [__v_1];
-        if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_177] = [__v_1];
+        if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_1: G = G::from_u64(2);
         let __v_2: G = G::from_u64(1);
         let __v_3: G = (__v_0 - __v_2);
-        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = (__v_1 * __v_4);
-        let __ret: [G; OUT_164] = [__v_5];
-        if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_177] = [__v_5];
+        if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_165: usize = 3;
-const IN_165: usize = 3;
-const OUT_165: usize = 8;
-fn aiur_fn_165(
-  inp: [G; IN_165],
+const INPUT_SIZE_178: usize = 3;
+const IN_178: usize = 3;
+const OUT_178: usize = 8;
+fn aiur_fn_178(
+  inp: [G; IN_178],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_165], 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];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = G::from_u64(1);
     let __v_6: G = G::from_u64(0);
     let __v_7: G = (__v_3 - __v_5);
     let __v_8: G = (__v_4 - __v_6);
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = g_inverse_value(__v_9);
     let __v_11: G = (__v_9 * __v_10);
@@ -15371,21 +16348,21 @@ fn aiur_fn_165(
     let __v_92: G = G::from_u64(0);
     let __v_93: G = (__v_92 - __v_8);
     let __v_94: G = (__v_93 * __v_83);
-    let __ret: [G; OUT_165] = [__v_43, __v_46, __v_71, __v_74, __v_76, __v_77, __v_91, __v_94];
-    if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_178] = [__v_43, __v_46, __v_71, __v_74, __v_76, __v_77, __v_91, __v_94];
+    if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_166: usize = 23;
-const IN_166: usize = 23;
-const OUT_166: usize = 1;
-fn aiur_fn_166(
-  inp: [G; IN_166],
+const INPUT_SIZE_179: usize = 24;
+const IN_179: usize = 24;
+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_166], ExecError> {
+) -> Result<[G; OUT_179], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15410,54 +16387,55 @@ fn aiur_fn_166(
     let __v_20: G = inp[20];
     let __v_21: G = inp[21];
     let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
     match __v_0.as_canonical_u64() {
       _ => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-        let __v_23: G = __r_arr[0];
-        let __v_24: G = G::from_bool((__v_23 == G::ZERO));
-        let __v_25: G = G::from_u64(0);
-        if (__v_24 != __v_25) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        if (__v_26 != __v_23) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __v_25: G = G::from_bool((__v_24 == G::ZERO));
+        let __v_26: G = G::from_u64(0);
+        if (__v_25 != __v_26) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
-        if (__v_27 != __v_23) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
+        if (__v_27 != __v_24) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
-        if (__v_28 != __v_23) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
+        if (__v_28 != __v_24) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
-        let __v_30: G = G::from_u64(1);
-        if (__v_29 != __v_30) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None });
+        if (__v_29 != __v_24) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None });
         }
+        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+        let __v_30: G = __r_arr[0];
         let __v_31: G = G::from_u64(1);
-        let __ret: [G; OUT_166] = [__v_31];
-        if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if (__v_30 != __v_31) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
+        }
+        let __v_32: G = G::from_u64(1);
+        let __ret: [G; OUT_179] = [__v_32];
+        if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_167: usize = 6;
-const IN_167: usize = 6;
-const OUT_167: usize = 2;
-fn aiur_fn_167(
-  inp: [G; IN_167],
+const INPUT_SIZE_180: usize = 6;
+const IN_180: usize = 6;
+const OUT_180: usize = 2;
+fn aiur_fn_180(
+  inp: [G; IN_180],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_167], 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];
@@ -15475,21 +16453,21 @@ fn aiur_fn_167(
     let __v_13: G = (__v_11 + __v_12);
     let __v_14: G = (__v_10 + __v_4);
     let __v_15: G = (__v_13 + __v_5);
-    let __ret: [G; OUT_167] = [__v_14, __v_15];
-    if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_180] = [__v_14, __v_15];
+    if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_168: usize = 4;
-const IN_168: usize = 4;
-const OUT_168: usize = 2;
-fn aiur_fn_168(
-  inp: [G; IN_168],
+const INPUT_SIZE_181: usize = 4;
+const IN_181: usize = 4;
+const OUT_181: usize = 2;
+fn aiur_fn_181(
+  inp: [G; IN_181],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_168], ExecError> {
+) -> Result<[G; OUT_181], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15507,21 +16485,21 @@ fn aiur_fn_168(
     let __v_13: G = (__v_11 + __v_12);
     let __v_14: G = (__v_0 + __v_10);
     let __v_15: G = (__v_1 + __v_13);
-    let __ret: [G; OUT_168] = [__v_14, __v_15];
-    if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_181] = [__v_14, __v_15];
+    if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_169: usize = 1;
-const IN_169: usize = 1;
-const OUT_169: usize = 1;
-fn aiur_fn_169(
-  inp: [G; IN_169],
+const INPUT_SIZE_182: usize = 1;
+const IN_182: usize = 1;
+const OUT_182: usize = 1;
+fn aiur_fn_182(
+  inp: [G; IN_182],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_169], ExecError> {
+) -> Result<[G; OUT_182], 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 };
@@ -15534,8 +16512,8 @@ fn aiur_fn_169(
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
         let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_169] = [__v_7];
-        if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_182] = [__v_7];
+        if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -15547,14 +16525,14 @@ fn aiur_fn_169(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_169] = [__v_13];
-            if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_182] = [__v_13];
+            if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -15569,15 +16547,15 @@ fn aiur_fn_169(
   })
 }
 
-const INPUT_SIZE_170: usize = 15;
-const IN_170: usize = 15;
-const OUT_170: usize = 2;
-fn aiur_fn_170(
-  inp: [G; IN_170],
+const INPUT_SIZE_183: usize = 15;
+const IN_183: usize = 15;
+const OUT_183: usize = 2;
+fn aiur_fn_183(
+  inp: [G; IN_183],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_170], 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];
@@ -15594,7 +16572,7 @@ fn aiur_fn_170(
     let __v_12: G = inp[12];
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
-    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
     let __v_17: G = __r_arr[2];
@@ -15602,8 +16580,8 @@ fn aiur_fn_170(
     match __v_15.as_canonical_u64() {
       0u64 => {
         let __v_19: G = G::from_u64(0);
-        let __ret: [G; OUT_170] = [__v_16, __v_19];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_16, __v_19];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
@@ -15611,109 +16589,109 @@ fn aiur_fn_170(
         let __v_20: G = (__v_16 + __v_19);
         match __v_20.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_183] = [__v_21, __v_22];
+            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_183] = [__v_21, __v_22];
+            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_183] = [__v_21, __v_22];
+            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_183] = [__v_21, __v_22];
+            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_183] = [__v_21, __v_22];
+            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_183] = [__v_21, __v_22];
+            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_8, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
-        let __ret: [G; OUT_170] = [__v_19, __v_20];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_19, __v_20];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
-        let __ret: [G; OUT_170] = [__v_9, __v_10];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_9, __v_10];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_170] = [__v_11, __v_12];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_11, __v_12];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_170] = [__v_13, __v_14];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_13, __v_14];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = (__v_19 + __v_21);
         let __v_24: G = (__v_20 + __v_22);
-        let __ret: [G; OUT_170] = [__v_23, __v_24];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_23, __v_24];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = (__v_19 - __v_21);
         let __v_24: G = (__v_20 - __v_22);
-        let __ret: [G; OUT_170] = [__v_23, __v_24];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_23, __v_24];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = (__v_19 * __v_21);
@@ -15724,20 +16702,20 @@ fn aiur_fn_170(
         let __v_28: G = (__v_19 * __v_22);
         let __v_29: G = (__v_20 * __v_21);
         let __v_30: G = (__v_28 + __v_29);
-        let __ret: [G; OUT_170] = [__v_27, __v_30];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_27, __v_30];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       9u64 => {
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = G::from_u64(0);
         let __v_22: G = (__v_21 - __v_19);
         let __v_23: G = G::from_u64(0);
         let __v_24: G = (__v_23 - __v_20);
-        let __ret: [G; OUT_170] = [__v_22, __v_24];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_183] = [__v_22, __v_24];
+        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -15747,15 +16725,15 @@ fn aiur_fn_170(
   })
 }
 
-const INPUT_SIZE_171: usize = 19;
-const IN_171: usize = 19;
-const OUT_171: usize = 2;
-fn aiur_fn_171(
-  inp: [G; IN_171],
+const INPUT_SIZE_184: usize = 19;
+const IN_184: usize = 19;
+const OUT_184: usize = 2;
+fn aiur_fn_184(
+  inp: [G; IN_184],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_171], 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];
@@ -15782,22 +16760,22 @@ fn aiur_fn_171(
     let __v_21: G = __loaded[2];
     match __v_19.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_171] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_184] = [__v_0, __v_1];
+        if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
         let __v_23: G = __r_arr[1];
-        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
         let __v_25: G = __r_arr[1];
-        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
         let __v_27: G = __r_arr[1];
-        let __ret: [G; OUT_171] = [__v_26, __v_27];
-        if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_184] = [__v_26, __v_27];
+        if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -15807,15 +16785,15 @@ fn aiur_fn_171(
   })
 }
 
-const INPUT_SIZE_172: usize = 8;
-const IN_172: usize = 8;
-const OUT_172: usize = 4;
-fn aiur_fn_172(
-  inp: [G; IN_172],
+const INPUT_SIZE_185: usize = 8;
+const IN_185: usize = 8;
+const OUT_185: usize = 4;
+fn aiur_fn_185(
+  inp: [G; IN_185],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_172], 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];
@@ -15871,21 +16849,21 @@ fn aiur_fn_172(
     let __v_51: G = (__v_15 + __v_33);
     let __v_52: G = (__v_38 + __v_46);
     let __v_53: G = (__v_41 + __v_49);
-    let __ret: [G; OUT_172] = [__v_50, __v_51, __v_52, __v_53];
-    if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_185] = [__v_50, __v_51, __v_52, __v_53];
+    if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_173: usize = 19;
-const IN_173: usize = 19;
-const OUT_173: usize = 4;
-fn aiur_fn_173(
-  inp: [G; IN_173],
+const INPUT_SIZE_186: usize = 19;
+const IN_186: usize = 19;
+const OUT_186: usize = 4;
+fn aiur_fn_186(
+  inp: [G; IN_186],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_173], 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];
@@ -15916,28 +16894,28 @@ fn aiur_fn_173(
         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_173] = [__v_22, __v_23, __v_24, __v_25];
-        if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_186] = [__v_22, __v_23, __v_24, __v_25];
+        if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
         let __v_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_172] = { let __args: [G; IN_172] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
         let __v_27: G = __r_arr[1];
         let __v_28: G = __r_arr[2];
         let __v_29: G = __r_arr[3];
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_30: G = __r_arr[0];
         let __v_31: G = __r_arr[1];
         let __v_32: G = (__v_26 + __v_30);
         let __v_33: G = (__v_27 + __v_31);
-        let __ret: [G; OUT_173] = [__v_32, __v_33, __v_28, __v_29];
-        if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_186] = [__v_32, __v_33, __v_28, __v_29];
+        if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -15947,15 +16925,15 @@ fn aiur_fn_173(
   })
 }
 
-const INPUT_SIZE_174: usize = 44;
-const IN_174: usize = 44;
-const OUT_174: usize = 2;
-fn aiur_fn_174(
-  inp: [G; IN_174],
+const INPUT_SIZE_187: usize = 44;
+const IN_187: usize = 44;
+const OUT_187: usize = 2;
+fn aiur_fn_187(
+  inp: [G; IN_187],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_174], 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];
@@ -16008,14 +16986,14 @@ fn aiur_fn_174(
     let __v_47: G = __loaded[3];
     match __v_44.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_174] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_187] = [__v_0, __v_1];
+        if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         match __v_45.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
             let __v_48: G = __r_arr[0];
             let __v_49: G = __r_arr[1];
             let __v_50: G = __r_arr[2];
@@ -16024,10 +17002,10 @@ fn aiur_fn_174(
             let __v_53: G = (__v_49 + __v_23);
             let __v_54: G = (__v_50 + __v_24);
             let __v_55: G = (__v_51 + __v_25);
-            let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
             let __v_56: G = __r_arr[0];
             let __v_57: G = __r_arr[1];
-            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
             let __v_58: G = __r_arr[0];
             let __v_59: G = __r_arr[1];
             let __v_60: G = __r_arr[2];
@@ -16052,7 +17030,7 @@ fn aiur_fn_174(
             let __v_79: G = (__v_77 + __v_78);
             let __v_80: G = (__v_60 + __v_76);
             let __v_81: G = (__v_61 + __v_79);
-            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
             let __v_82: G = __r_arr[0];
             let __v_83: G = __r_arr[1];
             let __v_84: G = __r_arr[2];
@@ -16063,23 +17041,23 @@ fn aiur_fn_174(
             match __v_88.as_canonical_u64() {
               0u64 => {
                 let __v_89: G = (__v_7 + __v_7);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_35, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
                 let __v_90: G = __r_arr[0];
                 let __v_91: G = __r_arr[1];
                 let __v_92: G = G::from_u64(1);
                 let __v_93: G = (__v_7 + __v_92);
                 let __v_94: G = (__v_7 + __v_93);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_35, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
                 let __v_95: G = __r_arr[0];
                 let __v_96: G = __r_arr[1];
                 let __v_97: G = G::from_u64(0);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_36, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_36, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
                 let __v_98: G = __r_arr[0];
                 let __v_99: G = __r_arr[1];
                 let __v_100: G = (__v_98 + __v_18);
                 let __v_101: G = (__v_99 + __v_19);
                 let __v_102: G = G::from_u64(1);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_36, __v_102]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_36, __v_102]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
                 let __v_103: G = __r_arr[0];
                 let __v_104: G = __r_arr[1];
                 let __v_105: G = (__v_103 + __v_20);
@@ -16088,23 +17066,23 @@ fn aiur_fn_174(
                 let __v_108: G = (__v_101 - __v_91);
                 let __v_109: G = (__v_105 - __v_95);
                 let __v_110: G = (__v_106 - __v_96);
-                let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
                 let __v_111: G = __r_arr[0];
                 let __v_112: G = __r_arr[1];
                 let __v_113: G = __r_arr[2];
                 let __v_114: G = __r_arr[3];
                 let __v_115: G = (__v_111 - __v_70);
                 let __v_116: G = (__v_112 - __v_71);
-                let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
                 let __v_117: G = __r_arr[0];
                 let __v_118: G = __r_arr[1];
                 let __v_119: G = (__v_113 - __v_80);
                 let __v_120: G = (__v_114 - __v_81);
-                let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
                 let __v_121: G = __r_arr[0];
                 let __v_122: G = __r_arr[1];
-                let __ret: [G; OUT_174] = [__v_121, __v_122];
-                if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_187] = [__v_121, __v_122];
+                if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
@@ -16113,44 +17091,44 @@ fn aiur_fn_174(
                 match __v_90.as_canonical_u64() {
                   0u64 => {
                     let __v_91: G = (__v_7 + __v_7);
-                    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_35, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
                     let __v_92: G = __r_arr[0];
                     let __v_93: G = __r_arr[1];
                     let __v_94: G = G::from_u64(1);
                     let __v_95: G = (__v_7 + __v_94);
                     let __v_96: G = (__v_7 + __v_95);
-                    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_35, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
                     let __v_97: G = __r_arr[0];
                     let __v_98: G = __r_arr[1];
                     let __v_99: G = G::from_u64(2);
                     let __v_100: G = (__v_7 + __v_99);
                     let __v_101: G = (__v_7 + __v_100);
-                    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_35, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
                     let __v_102: G = __r_arr[0];
                     let __v_103: G = __r_arr[1];
                     let __v_104: G = G::from_u64(3);
                     let __v_105: G = (__v_7 + __v_104);
                     let __v_106: G = (__v_7 + __v_105);
-                    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_35, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
                     let __v_107: G = __r_arr[0];
                     let __v_108: G = __r_arr[1];
                     let __v_109: G = (__v_102 - __v_92);
                     let __v_110: G = (__v_103 - __v_93);
                     let __v_111: G = (__v_107 - __v_97);
                     let __v_112: G = (__v_108 - __v_98);
-                    let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
                     let __v_113: G = __r_arr[0];
                     let __v_114: G = __r_arr[1];
                     let __v_115: G = __r_arr[2];
                     let __v_116: G = __r_arr[3];
                     let __v_117: G = (__v_113 - __v_70);
                     let __v_118: G = (__v_114 - __v_71);
-                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
                     let __v_119: G = __r_arr[0];
                     let __v_120: G = __r_arr[1];
                     let __v_121: G = (__v_115 - __v_80);
                     let __v_122: G = (__v_116 - __v_81);
-                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
                     let __v_123: G = __r_arr[0];
                     let __v_124: G = __r_arr[1];
                     let __v_125: G = G::from_u64(1);
@@ -16165,11 +17143,11 @@ fn aiur_fn_174(
                     let __v_134: G = G::from_u64(0);
                     let __v_135: G = G::from_u64(0);
                     let __v_136: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } };
                     let __v_137: G = __r_arr[0];
                     let __v_138: G = __r_arr[1];
-                    let __ret: [G; OUT_174] = [__v_137, __v_138];
-                    if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_187] = [__v_137, __v_138];
+                    if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                   _ => {
@@ -16177,11 +17155,11 @@ fn aiur_fn_174(
                     let __v_92: G = (__v_5 + __v_91);
                     let __v_93: G = G::from_u64(1);
                     let __v_94: G = (__v_8 - __v_93);
-                    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } };
                     let __v_95: G = __r_arr[0];
                     let __v_96: G = __r_arr[1];
-                    let __ret: [G; OUT_174] = [__v_95, __v_96];
-                    if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_187] = [__v_95, __v_96];
+                    if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                     return Ok(__ret);
                   },
                 }
@@ -16197,15 +17175,15 @@ fn aiur_fn_174(
   })
 }
 
-const INPUT_SIZE_175: usize = 28;
-const IN_175: usize = 28;
-const OUT_175: usize = 2;
-fn aiur_fn_175(
-  inp: [G; IN_175],
+const INPUT_SIZE_188: usize = 28;
+const IN_188: usize = 28;
+const OUT_188: usize = 2;
+fn aiur_fn_188(
+  inp: [G; IN_188],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_175], 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];
@@ -16237,7 +17215,7 @@ fn aiur_fn_175(
     let __v_27: G = inp[27];
     let __v_28: G = G::from_u64(0);
     let __v_29: G = G::from_u64(0);
-    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_28, __v_29, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_28, __v_29, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
     let __v_30: G = __r_arr[0];
     let __v_31: G = __r_arr[1];
     let __v_32: G = G::from_u64(0);
@@ -16294,42 +17272,42 @@ fn aiur_fn_175(
     match __v_78.as_canonical_u64() {
       1u64 => {
         let __v_82: G = G::from_u64(0);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_9, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_9, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
         let __v_83: G = __r_arr[0];
         let __v_84: G = __r_arr[1];
         let __v_85: G = G::from_u64(0);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_8, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
         let __v_86: G = __r_arr[0];
         let __v_87: G = __r_arr[1];
         let __v_88: G = (__v_83 - __v_86);
         let __v_89: G = (__v_84 - __v_87);
         let __v_90: G = (__v_88 + __v_55);
         let __v_91: G = (__v_89 + __v_58);
-        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
         let __v_92: G = __r_arr[0];
         let __v_93: G = __r_arr[1];
         let __v_94: G = G::from_u64(1);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_9, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_9, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
         let __v_95: G = __r_arr[0];
         let __v_96: G = __r_arr[1];
         let __v_97: G = G::from_u64(1);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_8, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
         let __v_98: G = __r_arr[0];
         let __v_99: G = __r_arr[1];
         let __v_100: G = (__v_95 - __v_98);
         let __v_101: G = (__v_96 - __v_99);
         let __v_102: G = (__v_100 + __v_74);
         let __v_103: G = (__v_101 + __v_77);
-        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
         let __v_104: G = __r_arr[0];
         let __v_105: G = __r_arr[1];
-        let __ret: [G; OUT_175] = [__v_104, __v_105];
-        if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_188] = [__v_104, __v_105];
+        if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         let __v_82: G = G::from_u64(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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
         let __v_83: G = __r_arr[0];
         let __v_84: G = G::from_u64(0);
         let __v_85: G = G::from_u64(1);
@@ -16340,11 +17318,11 @@ fn aiur_fn_175(
         let __v_90: G = G::from_u64(0);
         let __v_91: G = G::from_u64(0);
         let __v_92: G = G::from_u64(0);
-        let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_30, __v_31, __v_25, __v_26, __v_2, __v_82, __v_83, __v_84, __v_3, __v_3, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_55, __v_58, __v_74, __v_77, __v_11, __v_32, __v_12, __v_33, __v_13, __v_34, __v_14, __v_35, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_30, __v_31, __v_25, __v_26, __v_2, __v_82, __v_83, __v_84, __v_3, __v_3, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_55, __v_58, __v_74, __v_77, __v_11, __v_32, __v_12, __v_33, __v_13, __v_34, __v_14, __v_35, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } };
         let __v_93: G = __r_arr[0];
         let __v_94: G = __r_arr[1];
-        let __ret: [G; OUT_175] = [__v_93, __v_94];
-        if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_188] = [__v_93, __v_94];
+        if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -16354,15 +17332,15 @@ fn aiur_fn_175(
   })
 }
 
-const INPUT_SIZE_176: usize = 8;
-const IN_176: usize = 8;
-const OUT_176: usize = 1;
-fn aiur_fn_176(
-  inp: [G; IN_176],
+const INPUT_SIZE_189: usize = 8;
+const IN_189: usize = 8;
+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_176], 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];
@@ -16399,21 +17377,21 @@ fn aiur_fn_176(
     let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_176] = [__v_34];
-    if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_189] = [__v_34];
+    if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_177: usize = 5;
-const IN_177: usize = 5;
-const OUT_177: usize = 2;
-fn aiur_fn_177(
-  inp: [G; IN_177],
+const INPUT_SIZE_190: usize = 5;
+const IN_190: usize = 5;
+const OUT_190: usize = 2;
+fn aiur_fn_190(
+  inp: [G; IN_190],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_177], 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];
@@ -16429,8 +17407,8 @@ fn aiur_fn_177(
       1u64 => {
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_177] = [__v_9, __v_10];
-        if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_190] = [__v_9, __v_10];
+        if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -16450,13 +17428,13 @@ fn aiur_fn_177(
         let __v_22: G = (__v_3 * __v_2);
         let __v_23: G = (__v_4 * __v_1);
         let __v_24: G = (__v_22 + __v_23);
-        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = __r_arr[1];
         let __v_27: G = (__v_13 + __v_25);
         let __v_28: G = (__v_16 + __v_26);
-        let __ret: [G; OUT_177] = [__v_27, __v_28];
-        if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_190] = [__v_27, __v_28];
+        if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -16466,145 +17444,145 @@ fn aiur_fn_177(
   })
 }
 
-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_191: usize = 1;
+const IN_191: usize = 1;
+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_178], ExecError> {
+) -> Result<[G; OUT_191], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       3u64 => {
         let __v_1: G = G::from_u64(2);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       4u64 => {
         let __v_1: G = G::from_u64(4);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       5u64 => {
         let __v_1: G = G::from_u64(4);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       6u64 => {
         let __v_1: G = G::from_u64(8);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       7u64 => {
         let __v_1: G = G::from_u64(8);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       8u64 => {
         let __v_1: G = G::from_u64(8);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       9u64 => {
         let __v_1: G = G::from_u64(8);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       10u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       11u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       12u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       13u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       14u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       15u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       16u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       17u64 => {
         let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_1: G = G::from_u64(32);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_191] = [__v_1];
+        if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_179: usize = 4;
-const IN_179: usize = 4;
-const OUT_179: usize = 2;
-fn aiur_fn_179(
-  inp: [G; IN_179],
+const INPUT_SIZE_192: usize = 4;
+const IN_192: usize = 4;
+const OUT_192: usize = 2;
+fn aiur_fn_192(
+  inp: [G; IN_192],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_179], 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];
@@ -16618,8 +17596,8 @@ fn aiur_fn_179(
         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_179] = [__v_6, __v_9];
-        if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_192] = [__v_6, __v_9];
+        if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       1u64 => {
@@ -16631,21 +17609,21 @@ fn aiur_fn_179(
             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_179] = [__v_6, __v_9];
-            if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_192] = [__v_6, __v_9];
+            if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_4: G = __r_arr[0];
             let __v_5: G = G::from_u64(0);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             let __v_7: G = G::from_u64(1);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_179] = [__v_6, __v_8];
-            if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_192] = [__v_6, __v_8];
+            if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -16660,15 +17638,15 @@ fn aiur_fn_179(
   })
 }
 
-const INPUT_SIZE_180: usize = 20;
-const IN_180: usize = 20;
-const OUT_180: usize = 1;
-fn aiur_fn_180(
-  inp: [G; IN_180],
+const INPUT_SIZE_193: usize = 20;
+const IN_193: usize = 20;
+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_180], 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];
@@ -16702,37 +17680,37 @@ fn aiur_fn_180(
     match __v_20.as_canonical_u64() {
       1u64 => {
         let __v_28: G = G::from_u64(1);
-        let __ret: [G; OUT_180] = [__v_28];
-        if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_193] = [__v_28];
+        if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         match __v_21.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } };
             let __v_29: G = __r_arr[0];
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
             let __v_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_32: G = __r_arr[0];
             let __v_33: G = G::from_u64(0);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_34: G = __r_arr[0];
             let __v_35: G = G::from_u64(1);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_37: G = __r_arr[0];
             let __v_38: G = G::from_u64(0);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_39: G = __r_arr[0];
             let __v_40: G = G::from_u64(1);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_37, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_37, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_41: G = __r_arr[0];
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
             let __v_42: G = __r_arr[0];
             let __v_43: G = __r_arr[1];
             let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_42.as_canonical_u64() {
@@ -16757,13 +17735,13 @@ fn aiur_fn_180(
         break '__mc_0 [__v_46, __v_49];
       },
       1u64 => {
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_44: G = __r_arr[0];
         let __v_45: G = G::from_u64(0);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_46: G = __r_arr[0];
         let __v_47: G = G::from_u64(1);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_48: G = __r_arr[0];
         break '__mc_0 [__v_46, __v_48];
       },
@@ -16779,14 +17757,14 @@ fn aiur_fn_180(
  };
             let __v_44: G = __mc_out___mc_0[0];
             let __v_45: G = __mc_out___mc_0[1];
-            let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
             let __v_46: G = __r_arr[0];
             let __v_47: G = __r_arr[1];
             let __v_48: G = G::from_u64(1);
             let __v_49: G = G::from_u64(0);
             let __v_50: G = (__v_46 - __v_48);
             let __v_51: G = (__v_47 - __v_49);
-            let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
             let __v_52: G = __r_arr[0];
             let __v_53: G = g_inverse_value(__v_52);
             let __v_54: G = (__v_52 * __v_53);
@@ -16924,9 +17902,9 @@ fn aiur_fn_180(
             let __v_162: G = { let __values: [G; 4] = [__v_142, __v_14, __v_143, __v_161]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_163: G = { let __values: [G; 4] = [__v_140, __v_13, __v_141, __v_162]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_164: G = { let __values: [G; 4] = [__v_138, __v_12, __v_139, __v_163]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
             let __v_165: G = __r_arr[0];
-            let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
             let __v_166: G = __r_arr[0];
             let __v_167: G = (__v_165 * __v_166);
             let __v_168: G = g_inverse_value(__v_167);
@@ -16945,7 +17923,7 @@ fn aiur_fn_180(
             }
             let __v_176: G = G::from_u64(0);
             let __v_177: G = G::from_u64(0);
-            let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_176, __v_177, __v_16, __v_17, __v_23, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_176, __v_177, __v_16, __v_17, __v_23, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
             let __v_178: G = __r_arr[0];
             let __v_179: G = __r_arr[1];
             let __v_180: G = G::from_u64(0);
@@ -17002,40 +17980,40 @@ fn aiur_fn_180(
             let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_226.as_canonical_u64() {
   1u64 => {
     let __v_230: G = G::from_u64(0);
-    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_41, __v_230]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_41, __v_230]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
     let __v_231: G = __r_arr[0];
     let __v_232: G = __r_arr[1];
     let __v_233: G = G::from_u64(0);
-    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_39, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_39, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
     let __v_234: G = __r_arr[0];
     let __v_235: G = __r_arr[1];
     let __v_236: G = (__v_231 - __v_234);
     let __v_237: G = (__v_232 - __v_235);
     let __v_238: G = (__v_236 + __v_203);
     let __v_239: G = (__v_237 + __v_206);
-    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
     let __v_240: G = __r_arr[0];
     let __v_241: G = __r_arr[1];
     let __v_242: G = G::from_u64(1);
-    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_41, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_41, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
     let __v_243: G = __r_arr[0];
     let __v_244: G = __r_arr[1];
     let __v_245: G = G::from_u64(1);
-    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_39, __v_245]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_39, __v_245]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
     let __v_246: G = __r_arr[0];
     let __v_247: G = __r_arr[1];
     let __v_248: G = (__v_243 - __v_246);
     let __v_249: G = (__v_244 - __v_247);
     let __v_250: G = (__v_248 + __v_222);
     let __v_251: G = (__v_249 + __v_225);
-    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
     let __v_252: G = __r_arr[0];
     let __v_253: G = __r_arr[1];
     break '__mc_1 [__v_252, __v_253];
   },
   0u64 => {
     let __v_230: G = G::from_u64(0);
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
     let __v_231: G = __r_arr[0];
     let __v_232: G = G::from_u64(0);
     let __v_233: G = G::from_u64(1);
@@ -17046,7 +18024,7 @@ fn aiur_fn_180(
     let __v_238: G = G::from_u64(0);
     let __v_239: G = G::from_u64(0);
     let __v_240: G = G::from_u64(0);
-    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_178, __v_179, __v_16, __v_17, __v_25, __v_230, __v_231, __v_232, __v_26, __v_26, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_203, __v_206, __v_222, __v_225, __v_12, __v_180, __v_13, __v_181, __v_14, __v_182, __v_15, __v_183, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_178, __v_179, __v_16, __v_17, __v_25, __v_230, __v_231, __v_232, __v_26, __v_26, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_203, __v_206, __v_222, __v_225, __v_12, __v_180, __v_13, __v_181, __v_14, __v_182, __v_15, __v_183, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } };
     let __v_241: G = __r_arr[0];
     let __v_242: G = __r_arr[1];
     break '__mc_1 [__v_241, __v_242];
@@ -17058,19 +18036,19 @@ fn aiur_fn_180(
  };
             let __v_230: G = __mc_out___mc_1[0];
             let __v_231: G = __mc_out___mc_1[1];
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_232: G = __r_arr[0];
             let __v_233: G = G::from_u64(0);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_232, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_232, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_234: G = __r_arr[0];
-            let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_234]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_234]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
             let __v_235: G = __r_arr[0];
-            let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
             let __v_236: G = __r_arr[0];
             let __v_237: G = __r_arr[1];
             let __v_238: G = G::from_u64(1);
             let __v_239: G = G::from_u64(0);
-            let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_235, __v_236, __v_237, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_235, __v_236, __v_237, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
             let __v_240: G = __r_arr[0];
             let __v_241: G = __r_arr[1];
             let __v_242: G = (__v_230 * __v_134);
@@ -17087,7 +18065,7 @@ fn aiur_fn_180(
             if (__v_251 != __v_252) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_252.as_canonical_u64(), msg: None });
             }
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_235]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_235]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
             let __v_253: G = __r_arr[0];
             let __v_254: G = (__v_253 - __v_29);
             let __v_255: G = G::from_bool((__v_254 == G::ZERO));
@@ -17106,10 +18084,10 @@ fn aiur_fn_180(
             }
             let __v_263: G = G::from_u64(1);
             let __v_264: G = (__v_9 + __v_263);
-            let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_264, __v_30, __v_31, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_264, __v_30, __v_31, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
             let __v_265: G = __r_arr[0];
-            let __ret: [G; OUT_180] = [__v_265];
-            if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_193] = [__v_265];
+            if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
         }
@@ -17121,15 +18099,15 @@ fn aiur_fn_180(
   })
 }
 
-const INPUT_SIZE_181: usize = 3;
-const IN_181: usize = 3;
-const OUT_181: usize = 2;
-fn aiur_fn_181(
-  inp: [G; IN_181],
+const INPUT_SIZE_194: usize = 3;
+const IN_194: usize = 3;
+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_181], ExecError> {
+) -> Result<[G; OUT_194], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17149,8 +18127,8 @@ fn aiur_fn_181(
       1u64 => {
         let __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_181] = [__v_13, __v_14];
-        if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_194] = [__v_13, __v_14];
+        if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -17176,7 +18154,7 @@ fn aiur_fn_181(
         let __v_32: G = (__v_14 + __v_31);
         let __v_33: G = (__v_4 + __v_32);
         let __v_34: G = G::from_u64(0);
-        let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
         let __v_35: G = __r_arr[0];
         let __v_36: G = __r_arr[1];
         let __v_37: G = (__v_0 * __v_35);
@@ -17189,8 +18167,8 @@ fn aiur_fn_181(
         let __v_44: G = (__v_42 + __v_43);
         let __v_45: G = (__v_33 + __v_41);
         let __v_46: G = (__v_34 + __v_44);
-        let __ret: [G; OUT_181] = [__v_45, __v_46];
-        if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_194] = [__v_45, __v_46];
+        if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -17200,15 +18178,15 @@ fn aiur_fn_181(
   })
 }
 
-const INPUT_SIZE_182: usize = 7;
-const IN_182: usize = 7;
-const OUT_182: usize = 2;
-fn aiur_fn_182(
-  inp: [G; IN_182],
+const INPUT_SIZE_195: usize = 7;
+const IN_195: usize = 7;
+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_182], ExecError> {
+) -> Result<[G; OUT_195], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17223,12 +18201,12 @@ fn aiur_fn_182(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_182] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_195] = [__v_0, __v_1];
+        if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = (__v_3 + __v_10);
@@ -17258,11 +18236,11 @@ fn aiur_fn_182(
         let __v_30: G = (__v_29 * __v_19);
         let __v_31: G = (__v_0 + __v_27);
         let __v_32: G = (__v_1 + __v_30);
-        let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
         let __v_33: G = __r_arr[0];
         let __v_34: G = __r_arr[1];
-        let __ret: [G; OUT_182] = [__v_33, __v_34];
-        if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_195] = [__v_33, __v_34];
+        if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -17272,15 +18250,15 @@ fn aiur_fn_182(
   })
 }
 
-const INPUT_SIZE_183: usize = 37;
-const IN_183: usize = 37;
-const OUT_183: usize = 1;
-fn aiur_fn_183(
-  inp: [G; IN_183],
+const INPUT_SIZE_196: usize = 38;
+const IN_196: usize = 38;
+const OUT_196: usize = 1;
+fn aiur_fn_196(
+  inp: [G; IN_196],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_183], 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];
@@ -17319,24 +18297,25 @@ fn aiur_fn_183(
     let __v_34: G = inp[34];
     let __v_35: G = inp[35];
     let __v_36: G = inp[36];
+    let __v_37: G = inp[37];
     match __v_0.as_canonical_u64() {
       _ => {
         match __v_0.as_canonical_u64() {
           _ => {
             match __v_12.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
-                let __v_37: G = __r_arr[0];
-                let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
                 let __v_38: G = __r_arr[0];
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+                let __v_39: G = __r_arr[0];
                 match __v_13.as_canonical_u64() {
                   _ => {
                     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() {
   0u64 => {
-    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 } };
-    break '__mc_0 [__v_41];
+    let __v_41: G = G::from_u64(1);
+    let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    break '__mc_0 [__v_42];
   },
   1u64 => {
     break '__mc_0 [__v_10];
@@ -17346,522 +18325,557 @@ fn aiur_fn_183(
   },
 }
  };
-                    let __v_39: G = __mc_out___mc_0[0];
-                    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_17, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-                    let __v_40: G = __r_arr[0];
-                    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+                    let __v_40: G = __mc_out___mc_0[0];
+                    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_17, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
                     let __v_41: G = __r_arr[0];
-                    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_39, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_13, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
                     let __v_42: G = __r_arr[0];
-                    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_12, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_40, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
                     let __v_43: G = __r_arr[0];
-                    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_12, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
                     let __v_44: G = __r_arr[0];
-                    let __v_45: G = G::from_u64(0);
-                    let __v_46: G = G::from_u64(109);
-                    let __v_47: G = G::from_u64(0);
-                    let __v_48: G = G::from_u64(117);
-                    let __v_49: G = G::from_u64(0);
-                    let __v_50: G = G::from_u64(108);
-                    let __v_51: G = G::from_u64(0);
-                    let __v_52: G = G::from_u64(116);
-                    let __v_53: G = G::from_u64(0);
-                    let __v_54: G = G::from_u64(105);
-                    let __v_55: G = G::from_u64(0);
-                    let __v_56: G = G::from_u64(45);
-                    let __v_57: G = G::from_u64(0);
-                    let __v_58: G = G::from_u64(115);
-                    let __v_59: G = G::from_u64(0);
-                    let __v_60: G = G::from_u64(116);
-                    let __v_61: G = G::from_u64(0);
-                    let __v_62: G = G::from_u64(97);
-                    let __v_63: G = G::from_u64(0);
-                    let __v_64: G = G::from_u64(114);
-                    let __v_65: G = G::from_u64(0);
-                    let __v_66: G = G::from_u64(107);
-                    let __v_67: G = G::from_u64(0);
-                    let __v_68: G = G::from_u64(47);
-                    let __v_69: G = G::from_u64(0);
-                    let __v_70: G = G::from_u64(118);
-                    let __v_71: G = G::from_u64(0);
-                    let __v_72: G = G::from_u64(48);
-                    let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_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 __v_75: G = { let __values: [G; 3] = [__v_67, __v_68, __v_74]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = { let __values: [G; 3] = [__v_65, __v_66, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_77: G = { let __values: [G; 3] = [__v_63, __v_64, __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 __v_78: G = { let __values: [G; 3] = [__v_61, __v_62, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_79: G = { let __values: [G; 3] = [__v_59, __v_60, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_80: G = { let __values: [G; 3] = [__v_57, __v_58, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_81: G = { let __values: [G; 3] = [__v_55, __v_56, __v_80]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_82: G = { let __values: [G; 3] = [__v_53, __v_54, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_83: G = { let __values: [G; 3] = [__v_51, __v_52, __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 __v_84: G = { let __values: [G; 3] = [__v_49, __v_50, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_85: G = { let __values: [G; 3] = [__v_47, __v_48, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_86: G = { let __values: [G; 3] = [__v_45, __v_46, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_87: G = G::from_u64(1);
+                    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_7, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+                    let __v_45: G = __r_arr[0];
+                    let __v_46: G = G::from_u64(0);
+                    let __v_47: G = G::from_u64(109);
+                    let __v_48: G = G::from_u64(0);
+                    let __v_49: G = G::from_u64(117);
+                    let __v_50: G = G::from_u64(0);
+                    let __v_51: G = G::from_u64(108);
+                    let __v_52: G = G::from_u64(0);
+                    let __v_53: G = G::from_u64(116);
+                    let __v_54: G = G::from_u64(0);
+                    let __v_55: G = G::from_u64(105);
+                    let __v_56: G = G::from_u64(0);
+                    let __v_57: G = G::from_u64(45);
+                    let __v_58: G = G::from_u64(0);
+                    let __v_59: G = G::from_u64(115);
+                    let __v_60: G = G::from_u64(0);
+                    let __v_61: G = G::from_u64(116);
+                    let __v_62: G = G::from_u64(0);
+                    let __v_63: G = G::from_u64(97);
+                    let __v_64: G = G::from_u64(0);
+                    let __v_65: G = G::from_u64(114);
+                    let __v_66: G = G::from_u64(0);
+                    let __v_67: G = G::from_u64(107);
+                    let __v_68: G = G::from_u64(0);
+                    let __v_69: G = G::from_u64(47);
+                    let __v_70: G = G::from_u64(0);
+                    let __v_71: G = G::from_u64(118);
+                    let __v_72: G = G::from_u64(0);
+                    let __v_73: G = G::from_u64(48);
+                    let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_75: G = { let __values: [G; 3] = [__v_70, __v_71, __v_74]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = { let __values: [G; 3] = [__v_68, __v_69, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_77: G = { let __values: [G; 3] = [__v_66, __v_67, __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 __v_78: G = { let __values: [G; 3] = [__v_64, __v_65, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_79: G = { let __values: [G; 3] = [__v_62, __v_63, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_80: G = { let __values: [G; 3] = [__v_60, __v_61, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_81: G = { let __values: [G; 3] = [__v_58, __v_59, __v_80]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_82: G = { let __values: [G; 3] = [__v_56, __v_57, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_83: G = { let __values: [G; 3] = [__v_54, __v_55, __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 __v_84: G = { let __values: [G; 3] = [__v_52, __v_53, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_85: G = { let __values: [G; 3] = [__v_50, __v_51, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_86: G = { let __values: [G; 3] = [__v_48, __v_49, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_87: G = { let __values: [G; 3] = [__v_46, __v_47, __v_86]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                     let __v_88: G = G::from_u64(1);
-                    let __v_89: G = { let __values: [G; 3] = [__v_87, __v_88, __v_88]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_86, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                    let __v_90: G = __r_arr[0];
-                    let __v_91: G = __r_arr[1];
-                    let __v_92: G = __r_arr[2];
-                    let __v_93: G = __r_arr[3];
-                    let __v_94: G = __r_arr[4];
-                    let __v_95: G = __r_arr[5];
-                    let __v_96: G = __r_arr[6];
-                    let __v_97: G = __r_arr[7];
-                    let __v_98: G = __r_arr[8];
-                    let __v_99: G = __r_arr[9];
-                    let __v_100: G = __r_arr[10];
-                    let __v_101: G = __r_arr[11];
-                    let __v_102: G = __r_arr[12];
-                    let __v_103: G = __r_arr[13];
-                    let __v_104: G = __r_arr[14];
-                    let __v_105: G = __r_arr[15];
-                    let __v_106: G = __r_arr[16];
-                    let __v_107: G = __r_arr[17];
-                    let __v_108: G = G::from_u64(1);
+                    let __v_89: G = G::from_u64(1);
+                    let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_87, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                    let __v_91: G = __r_arr[0];
+                    let __v_92: G = __r_arr[1];
+                    let __v_93: G = __r_arr[2];
+                    let __v_94: G = __r_arr[3];
+                    let __v_95: G = __r_arr[4];
+                    let __v_96: G = __r_arr[5];
+                    let __v_97: G = __r_arr[6];
+                    let __v_98: G = __r_arr[7];
+                    let __v_99: G = __r_arr[8];
+                    let __v_100: G = __r_arr[9];
+                    let __v_101: G = __r_arr[10];
+                    let __v_102: G = __r_arr[11];
+                    let __v_103: G = __r_arr[12];
+                    let __v_104: G = __r_arr[13];
+                    let __v_105: G = __r_arr[14];
+                    let __v_106: G = __r_arr[15];
+                    let __v_107: G = __r_arr[16];
+                    let __v_108: G = __r_arr[17];
                     let __v_109: G = G::from_u64(1);
-                    let __v_110: G = { let __values: [G; 3] = [__v_108, __v_109, __v_109]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                    let __v_111: G = __r_arr[0];
-                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+                    let __v_110: G = G::from_u64(1);
+                    let __v_111: G = { let __values: [G; 3] = [__v_109, __v_110, __v_110]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
                     let __v_112: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_106, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
                     let __v_113: G = __r_arr[0];
-                    let __v_114: G = G::from_u64(1);
+                    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_107, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
+                    let __v_114: G = __r_arr[0];
                     let __v_115: G = G::from_u64(1);
-                    let __v_116: G = { let __values: [G; 3] = [__v_114, __v_115, __v_115]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_113, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                    let __v_117: G = __r_arr[0];
-                    let __v_118: G = __r_arr[1];
-                    let __v_119: G = __r_arr[2];
-                    let __v_120: G = __r_arr[3];
-                    let __v_121: G = __r_arr[4];
-                    let __v_122: G = __r_arr[5];
-                    let __v_123: G = __r_arr[6];
-                    let __v_124: G = __r_arr[7];
-                    let __v_125: G = __r_arr[8];
-                    let __v_126: G = __r_arr[9];
-                    let __v_127: G = __r_arr[10];
-                    let __v_128: G = __r_arr[11];
-                    let __v_129: G = __r_arr[12];
-                    let __v_130: G = __r_arr[13];
-                    let __v_131: G = __r_arr[14];
-                    let __v_132: G = __r_arr[15];
-                    let __v_133: G = __r_arr[16];
-                    let __v_134: G = __r_arr[17];
-                    let __v_135: G = G::from_u64(1);
+                    let __v_116: G = G::from_u64(1);
+                    let __v_117: G = { let __values: [G; 3] = [__v_115, __v_116, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_114, __v_117]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                    let __v_118: G = __r_arr[0];
+                    let __v_119: G = __r_arr[1];
+                    let __v_120: G = __r_arr[2];
+                    let __v_121: G = __r_arr[3];
+                    let __v_122: G = __r_arr[4];
+                    let __v_123: G = __r_arr[5];
+                    let __v_124: G = __r_arr[6];
+                    let __v_125: G = __r_arr[7];
+                    let __v_126: G = __r_arr[8];
+                    let __v_127: G = __r_arr[9];
+                    let __v_128: G = __r_arr[10];
+                    let __v_129: G = __r_arr[11];
+                    let __v_130: G = __r_arr[12];
+                    let __v_131: G = __r_arr[13];
+                    let __v_132: G = __r_arr[14];
+                    let __v_133: G = __r_arr[15];
+                    let __v_134: G = __r_arr[16];
+                    let __v_135: G = __r_arr[17];
                     let __v_136: G = G::from_u64(1);
-                    let __v_137: G = { let __values: [G; 3] = [__v_135, __v_136, __v_136]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_137]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                    let __v_138: G = __r_arr[0];
-                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_138]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+                    let __v_137: G = G::from_u64(1);
+                    let __v_138: G = { let __values: [G; 3] = [__v_136, __v_137, __v_137]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_138]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
                     let __v_139: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_133, __v_139]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_139]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
                     let __v_140: G = __r_arr[0];
-                    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_140, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_134, __v_140]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
                     let __v_141: G = __r_arr[0];
-                    let __v_142: G = G::from_u64(1);
+                    let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_141, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
+                    let __v_142: G = __r_arr[0];
                     let __v_143: G = G::from_u64(1);
-                    let __v_144: G = { let __values: [G; 3] = [__v_142, __v_143, __v_143]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_16, __v_144]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_145: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_141, __v_145]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+                    let __v_144: G = G::from_u64(1);
+                    let __v_145: G = { let __values: [G; 3] = [__v_143, __v_144, __v_144]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_16, __v_145]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
                     let __v_146: G = __r_arr[0];
-                    let __v_147: G = G::from_u64(1);
+                    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_142, __v_146]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
+                    let __v_147: G = __r_arr[0];
                     let __v_148: G = G::from_u64(1);
-                    let __v_149: G = { let __values: [G; 3] = [__v_147, __v_148, __v_148]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_146, __v_149]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                    let __v_150: G = __r_arr[0];
-                    let __v_151: G = __r_arr[1];
-                    let __v_152: G = __r_arr[2];
-                    let __v_153: G = __r_arr[3];
-                    let __v_154: G = __r_arr[4];
-                    let __v_155: G = __r_arr[5];
-                    let __v_156: G = __r_arr[6];
-                    let __v_157: G = __r_arr[7];
-                    let __v_158: G = __r_arr[8];
-                    let __v_159: G = __r_arr[9];
-                    let __v_160: G = __r_arr[10];
-                    let __v_161: G = __r_arr[11];
-                    let __v_162: G = __r_arr[12];
-                    let __v_163: G = __r_arr[13];
-                    let __v_164: G = __r_arr[14];
-                    let __v_165: G = __r_arr[15];
-                    let __v_166: G = __r_arr[16];
-                    let __v_167: G = __r_arr[17];
-                    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_166, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-                    let __v_168: G = __r_arr[0];
-                    let __v_169: 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_165] = { let __args: [G; IN_165] = [__v_147, __v_150]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                    let __v_151: G = __r_arr[0];
+                    let __v_152: G = __r_arr[1];
+                    let __v_153: G = __r_arr[2];
+                    let __v_154: G = __r_arr[3];
+                    let __v_155: G = __r_arr[4];
+                    let __v_156: G = __r_arr[5];
+                    let __v_157: G = __r_arr[6];
+                    let __v_158: G = __r_arr[7];
+                    let __v_159: G = __r_arr[8];
+                    let __v_160: G = __r_arr[9];
+                    let __v_161: G = __r_arr[10];
+                    let __v_162: G = __r_arr[11];
+                    let __v_163: G = __r_arr[12];
+                    let __v_164: G = __r_arr[13];
+                    let __v_165: G = __r_arr[14];
+                    let __v_166: G = __r_arr[15];
+                    let __v_167: G = __r_arr[16];
+                    let __v_168: G = __r_arr[17];
+                    let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_167, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
+                    let __v_169: G = __r_arr[0];
                     let __v_170: G = G::from_u64(1);
-                    let __v_171: G = { let __values: [G; 3] = [__v_169, __v_170, __v_170]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_168, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                    let __v_172: G = __r_arr[0];
-                    let __v_173: G = __r_arr[1];
-                    let __v_174: G = __r_arr[2];
-                    let __v_175: G = __r_arr[3];
-                    let __v_176: G = __r_arr[4];
-                    let __v_177: G = __r_arr[5];
-                    let __v_178: G = __r_arr[6];
-                    let __v_179: G = __r_arr[7];
-                    let __v_180: G = __r_arr[8];
-                    let __v_181: G = __r_arr[9];
-                    let __v_182: G = __r_arr[10];
-                    let __v_183: G = __r_arr[11];
-                    let __v_184: G = __r_arr[12];
-                    let __v_185: G = __r_arr[13];
-                    let __v_186: G = __r_arr[14];
-                    let __v_187: G = __r_arr[15];
-                    let __v_188: G = __r_arr[16];
-                    let __v_189: G = __r_arr[17];
-                    let __v_190: G = G::from_u64(256);
-                    let __v_191: G = (__v_190 * __v_91);
-                    let __v_192: G = G::from_u64(65536);
-                    let __v_193: G = (__v_192 * __v_92);
-                    let __v_194: G = G::from_u64(16777216);
-                    let __v_195: G = (__v_194 * __v_93);
-                    let __v_196: G = G::from_u64(4294967296);
-                    let __v_197: G = (__v_196 * __v_94);
-                    let __v_198: G = G::from_u64(1099511627776);
-                    let __v_199: G = (__v_198 * __v_95);
-                    let __v_200: G = G::from_u64(281474976710656);
-                    let __v_201: G = (__v_200 * __v_96);
-                    let __v_202: G = G::from_u64(72057594037927936);
-                    let __v_203: G = (__v_202 * __v_97);
-                    let __v_204: G = (__v_201 + __v_203);
-                    let __v_205: G = (__v_199 + __v_204);
-                    let __v_206: G = (__v_197 + __v_205);
-                    let __v_207: G = (__v_195 + __v_206);
-                    let __v_208: G = (__v_193 + __v_207);
-                    let __v_209: G = (__v_191 + __v_208);
-                    let __v_210: G = (__v_90 + __v_209);
-                    let __v_211: G = G::from_u64(256);
-                    let __v_212: G = (__v_211 * __v_99);
-                    let __v_213: G = G::from_u64(65536);
-                    let __v_214: G = (__v_213 * __v_100);
-                    let __v_215: G = G::from_u64(16777216);
-                    let __v_216: G = (__v_215 * __v_101);
-                    let __v_217: G = G::from_u64(4294967296);
-                    let __v_218: G = (__v_217 * __v_102);
-                    let __v_219: G = G::from_u64(1099511627776);
-                    let __v_220: G = (__v_219 * __v_103);
-                    let __v_221: G = G::from_u64(281474976710656);
-                    let __v_222: G = (__v_221 * __v_104);
-                    let __v_223: G = G::from_u64(72057594037927936);
-                    let __v_224: G = (__v_223 * __v_105);
-                    let __v_225: G = (__v_222 + __v_224);
-                    let __v_226: G = (__v_220 + __v_225);
-                    let __v_227: G = (__v_218 + __v_226);
-                    let __v_228: G = (__v_216 + __v_227);
-                    let __v_229: G = (__v_214 + __v_228);
-                    let __v_230: G = (__v_212 + __v_229);
-                    let __v_231: G = (__v_98 + __v_230);
-                    let __v_232: G = G::from_u64(256);
-                    let __v_233: G = (__v_232 * __v_118);
-                    let __v_234: G = G::from_u64(65536);
-                    let __v_235: G = (__v_234 * __v_119);
-                    let __v_236: G = G::from_u64(16777216);
-                    let __v_237: G = (__v_236 * __v_120);
-                    let __v_238: G = G::from_u64(4294967296);
-                    let __v_239: G = (__v_238 * __v_121);
-                    let __v_240: G = G::from_u64(1099511627776);
-                    let __v_241: G = (__v_240 * __v_122);
-                    let __v_242: G = G::from_u64(281474976710656);
-                    let __v_243: G = (__v_242 * __v_123);
-                    let __v_244: G = G::from_u64(72057594037927936);
-                    let __v_245: G = (__v_244 * __v_124);
-                    let __v_246: G = (__v_243 + __v_245);
-                    let __v_247: G = (__v_241 + __v_246);
-                    let __v_248: G = (__v_239 + __v_247);
-                    let __v_249: G = (__v_237 + __v_248);
-                    let __v_250: G = (__v_235 + __v_249);
-                    let __v_251: G = (__v_233 + __v_250);
-                    let __v_252: G = (__v_117 + __v_251);
-                    let __v_253: G = G::from_u64(256);
-                    let __v_254: G = (__v_253 * __v_126);
-                    let __v_255: G = G::from_u64(65536);
-                    let __v_256: G = (__v_255 * __v_127);
-                    let __v_257: G = G::from_u64(16777216);
-                    let __v_258: G = (__v_257 * __v_128);
-                    let __v_259: G = G::from_u64(4294967296);
-                    let __v_260: G = (__v_259 * __v_129);
-                    let __v_261: G = G::from_u64(1099511627776);
-                    let __v_262: G = (__v_261 * __v_130);
-                    let __v_263: G = G::from_u64(281474976710656);
-                    let __v_264: G = (__v_263 * __v_131);
-                    let __v_265: G = G::from_u64(72057594037927936);
-                    let __v_266: G = (__v_265 * __v_132);
-                    let __v_267: G = (__v_264 + __v_266);
-                    let __v_268: G = (__v_262 + __v_267);
-                    let __v_269: G = (__v_260 + __v_268);
-                    let __v_270: G = (__v_258 + __v_269);
-                    let __v_271: G = (__v_256 + __v_270);
-                    let __v_272: G = (__v_254 + __v_271);
-                    let __v_273: G = (__v_125 + __v_272);
-                    let __v_274: G = G::from_u64(256);
-                    let __v_275: G = (__v_274 * __v_151);
-                    let __v_276: G = G::from_u64(65536);
-                    let __v_277: G = (__v_276 * __v_152);
-                    let __v_278: G = G::from_u64(16777216);
-                    let __v_279: G = (__v_278 * __v_153);
-                    let __v_280: G = G::from_u64(4294967296);
-                    let __v_281: G = (__v_280 * __v_154);
-                    let __v_282: G = G::from_u64(1099511627776);
-                    let __v_283: G = (__v_282 * __v_155);
-                    let __v_284: G = G::from_u64(281474976710656);
-                    let __v_285: G = (__v_284 * __v_156);
-                    let __v_286: G = G::from_u64(72057594037927936);
-                    let __v_287: G = (__v_286 * __v_157);
-                    let __v_288: G = (__v_285 + __v_287);
-                    let __v_289: G = (__v_283 + __v_288);
-                    let __v_290: G = (__v_281 + __v_289);
-                    let __v_291: G = (__v_279 + __v_290);
-                    let __v_292: G = (__v_277 + __v_291);
-                    let __v_293: G = (__v_275 + __v_292);
-                    let __v_294: G = (__v_150 + __v_293);
-                    let __v_295: G = G::from_u64(256);
-                    let __v_296: G = (__v_295 * __v_159);
-                    let __v_297: G = G::from_u64(65536);
-                    let __v_298: G = (__v_297 * __v_160);
-                    let __v_299: G = G::from_u64(16777216);
-                    let __v_300: G = (__v_299 * __v_161);
-                    let __v_301: G = G::from_u64(4294967296);
-                    let __v_302: G = (__v_301 * __v_162);
-                    let __v_303: G = G::from_u64(1099511627776);
-                    let __v_304: G = (__v_303 * __v_163);
-                    let __v_305: G = G::from_u64(281474976710656);
-                    let __v_306: G = (__v_305 * __v_164);
-                    let __v_307: G = G::from_u64(72057594037927936);
-                    let __v_308: G = (__v_307 * __v_165);
-                    let __v_309: G = (__v_306 + __v_308);
-                    let __v_310: G = (__v_304 + __v_309);
-                    let __v_311: G = (__v_302 + __v_310);
-                    let __v_312: G = (__v_300 + __v_311);
-                    let __v_313: G = (__v_298 + __v_312);
-                    let __v_314: G = (__v_296 + __v_313);
-                    let __v_315: G = (__v_158 + __v_314);
-                    let __v_316: G = G::from_u64(256);
-                    let __v_317: G = (__v_316 * __v_173);
-                    let __v_318: G = G::from_u64(65536);
-                    let __v_319: G = (__v_318 * __v_174);
-                    let __v_320: G = G::from_u64(16777216);
-                    let __v_321: G = (__v_320 * __v_175);
-                    let __v_322: G = G::from_u64(4294967296);
-                    let __v_323: G = (__v_322 * __v_176);
-                    let __v_324: G = G::from_u64(1099511627776);
-                    let __v_325: G = (__v_324 * __v_177);
-                    let __v_326: G = G::from_u64(281474976710656);
-                    let __v_327: G = (__v_326 * __v_178);
-                    let __v_328: G = G::from_u64(72057594037927936);
-                    let __v_329: G = (__v_328 * __v_179);
-                    let __v_330: G = (__v_327 + __v_329);
-                    let __v_331: G = (__v_325 + __v_330);
-                    let __v_332: G = (__v_323 + __v_331);
-                    let __v_333: G = (__v_321 + __v_332);
-                    let __v_334: G = (__v_319 + __v_333);
-                    let __v_335: G = (__v_317 + __v_334);
-                    let __v_336: G = (__v_172 + __v_335);
-                    let __v_337: G = G::from_u64(256);
-                    let __v_338: G = (__v_337 * __v_181);
-                    let __v_339: G = G::from_u64(65536);
-                    let __v_340: G = (__v_339 * __v_182);
-                    let __v_341: G = G::from_u64(16777216);
-                    let __v_342: G = (__v_341 * __v_183);
-                    let __v_343: G = G::from_u64(4294967296);
-                    let __v_344: G = (__v_343 * __v_184);
-                    let __v_345: G = G::from_u64(1099511627776);
-                    let __v_346: G = (__v_345 * __v_185);
-                    let __v_347: G = G::from_u64(281474976710656);
-                    let __v_348: G = (__v_347 * __v_186);
-                    let __v_349: G = G::from_u64(72057594037927936);
-                    let __v_350: G = (__v_349 * __v_187);
-                    let __v_351: G = (__v_348 + __v_350);
-                    let __v_352: G = (__v_346 + __v_351);
-                    let __v_353: G = (__v_344 + __v_352);
-                    let __v_354: G = (__v_342 + __v_353);
-                    let __v_355: G = (__v_340 + __v_354);
-                    let __v_356: G = (__v_338 + __v_355);
-                    let __v_357: G = (__v_180 + __v_356);
-                    let __v_358: G = G::from_u64(0);
+                    let __v_171: G = G::from_u64(1);
+                    let __v_172: G = { let __values: [G; 3] = [__v_170, __v_171, __v_171]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_169, __v_172]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                    let __v_173: G = __r_arr[0];
+                    let __v_174: G = __r_arr[1];
+                    let __v_175: G = __r_arr[2];
+                    let __v_176: G = __r_arr[3];
+                    let __v_177: G = __r_arr[4];
+                    let __v_178: G = __r_arr[5];
+                    let __v_179: G = __r_arr[6];
+                    let __v_180: G = __r_arr[7];
+                    let __v_181: G = __r_arr[8];
+                    let __v_182: G = __r_arr[9];
+                    let __v_183: G = __r_arr[10];
+                    let __v_184: G = __r_arr[11];
+                    let __v_185: G = __r_arr[12];
+                    let __v_186: G = __r_arr[13];
+                    let __v_187: G = __r_arr[14];
+                    let __v_188: G = __r_arr[15];
+                    let __v_189: G = __r_arr[16];
+                    let __v_190: G = __r_arr[17];
+                    let __v_191: G = G::from_u64(256);
+                    let __v_192: G = (__v_191 * __v_92);
+                    let __v_193: G = G::from_u64(65536);
+                    let __v_194: G = (__v_193 * __v_93);
+                    let __v_195: G = G::from_u64(16777216);
+                    let __v_196: G = (__v_195 * __v_94);
+                    let __v_197: G = G::from_u64(4294967296);
+                    let __v_198: G = (__v_197 * __v_95);
+                    let __v_199: G = G::from_u64(1099511627776);
+                    let __v_200: G = (__v_199 * __v_96);
+                    let __v_201: G = G::from_u64(281474976710656);
+                    let __v_202: G = (__v_201 * __v_97);
+                    let __v_203: G = G::from_u64(72057594037927936);
+                    let __v_204: G = (__v_203 * __v_98);
+                    let __v_205: G = (__v_202 + __v_204);
+                    let __v_206: G = (__v_200 + __v_205);
+                    let __v_207: G = (__v_198 + __v_206);
+                    let __v_208: G = (__v_196 + __v_207);
+                    let __v_209: G = (__v_194 + __v_208);
+                    let __v_210: G = (__v_192 + __v_209);
+                    let __v_211: G = (__v_91 + __v_210);
+                    let __v_212: G = G::from_u64(256);
+                    let __v_213: G = (__v_212 * __v_100);
+                    let __v_214: G = G::from_u64(65536);
+                    let __v_215: G = (__v_214 * __v_101);
+                    let __v_216: G = G::from_u64(16777216);
+                    let __v_217: G = (__v_216 * __v_102);
+                    let __v_218: G = G::from_u64(4294967296);
+                    let __v_219: G = (__v_218 * __v_103);
+                    let __v_220: G = G::from_u64(1099511627776);
+                    let __v_221: G = (__v_220 * __v_104);
+                    let __v_222: G = G::from_u64(281474976710656);
+                    let __v_223: G = (__v_222 * __v_105);
+                    let __v_224: G = G::from_u64(72057594037927936);
+                    let __v_225: G = (__v_224 * __v_106);
+                    let __v_226: G = (__v_223 + __v_225);
+                    let __v_227: G = (__v_221 + __v_226);
+                    let __v_228: G = (__v_219 + __v_227);
+                    let __v_229: G = (__v_217 + __v_228);
+                    let __v_230: G = (__v_215 + __v_229);
+                    let __v_231: G = (__v_213 + __v_230);
+                    let __v_232: G = (__v_99 + __v_231);
+                    let __v_233: G = G::from_u64(256);
+                    let __v_234: G = (__v_233 * __v_119);
+                    let __v_235: G = G::from_u64(65536);
+                    let __v_236: G = (__v_235 * __v_120);
+                    let __v_237: G = G::from_u64(16777216);
+                    let __v_238: G = (__v_237 * __v_121);
+                    let __v_239: G = G::from_u64(4294967296);
+                    let __v_240: G = (__v_239 * __v_122);
+                    let __v_241: G = G::from_u64(1099511627776);
+                    let __v_242: G = (__v_241 * __v_123);
+                    let __v_243: G = G::from_u64(281474976710656);
+                    let __v_244: G = (__v_243 * __v_124);
+                    let __v_245: G = G::from_u64(72057594037927936);
+                    let __v_246: G = (__v_245 * __v_125);
+                    let __v_247: G = (__v_244 + __v_246);
+                    let __v_248: G = (__v_242 + __v_247);
+                    let __v_249: G = (__v_240 + __v_248);
+                    let __v_250: G = (__v_238 + __v_249);
+                    let __v_251: G = (__v_236 + __v_250);
+                    let __v_252: G = (__v_234 + __v_251);
+                    let __v_253: G = (__v_118 + __v_252);
+                    let __v_254: G = G::from_u64(256);
+                    let __v_255: G = (__v_254 * __v_127);
+                    let __v_256: G = G::from_u64(65536);
+                    let __v_257: G = (__v_256 * __v_128);
+                    let __v_258: G = G::from_u64(16777216);
+                    let __v_259: G = (__v_258 * __v_129);
+                    let __v_260: G = G::from_u64(4294967296);
+                    let __v_261: G = (__v_260 * __v_130);
+                    let __v_262: G = G::from_u64(1099511627776);
+                    let __v_263: G = (__v_262 * __v_131);
+                    let __v_264: G = G::from_u64(281474976710656);
+                    let __v_265: G = (__v_264 * __v_132);
+                    let __v_266: G = G::from_u64(72057594037927936);
+                    let __v_267: G = (__v_266 * __v_133);
+                    let __v_268: G = (__v_265 + __v_267);
+                    let __v_269: G = (__v_263 + __v_268);
+                    let __v_270: G = (__v_261 + __v_269);
+                    let __v_271: G = (__v_259 + __v_270);
+                    let __v_272: G = (__v_257 + __v_271);
+                    let __v_273: G = (__v_255 + __v_272);
+                    let __v_274: G = (__v_126 + __v_273);
+                    let __v_275: G = G::from_u64(256);
+                    let __v_276: G = (__v_275 * __v_152);
+                    let __v_277: G = G::from_u64(65536);
+                    let __v_278: G = (__v_277 * __v_153);
+                    let __v_279: G = G::from_u64(16777216);
+                    let __v_280: G = (__v_279 * __v_154);
+                    let __v_281: G = G::from_u64(4294967296);
+                    let __v_282: G = (__v_281 * __v_155);
+                    let __v_283: G = G::from_u64(1099511627776);
+                    let __v_284: G = (__v_283 * __v_156);
+                    let __v_285: G = G::from_u64(281474976710656);
+                    let __v_286: G = (__v_285 * __v_157);
+                    let __v_287: G = G::from_u64(72057594037927936);
+                    let __v_288: G = (__v_287 * __v_158);
+                    let __v_289: G = (__v_286 + __v_288);
+                    let __v_290: G = (__v_284 + __v_289);
+                    let __v_291: G = (__v_282 + __v_290);
+                    let __v_292: G = (__v_280 + __v_291);
+                    let __v_293: G = (__v_278 + __v_292);
+                    let __v_294: G = (__v_276 + __v_293);
+                    let __v_295: G = (__v_151 + __v_294);
+                    let __v_296: G = G::from_u64(256);
+                    let __v_297: G = (__v_296 * __v_160);
+                    let __v_298: G = G::from_u64(65536);
+                    let __v_299: G = (__v_298 * __v_161);
+                    let __v_300: G = G::from_u64(16777216);
+                    let __v_301: G = (__v_300 * __v_162);
+                    let __v_302: G = G::from_u64(4294967296);
+                    let __v_303: G = (__v_302 * __v_163);
+                    let __v_304: G = G::from_u64(1099511627776);
+                    let __v_305: G = (__v_304 * __v_164);
+                    let __v_306: G = G::from_u64(281474976710656);
+                    let __v_307: G = (__v_306 * __v_165);
+                    let __v_308: G = G::from_u64(72057594037927936);
+                    let __v_309: G = (__v_308 * __v_166);
+                    let __v_310: G = (__v_307 + __v_309);
+                    let __v_311: G = (__v_305 + __v_310);
+                    let __v_312: G = (__v_303 + __v_311);
+                    let __v_313: G = (__v_301 + __v_312);
+                    let __v_314: G = (__v_299 + __v_313);
+                    let __v_315: G = (__v_297 + __v_314);
+                    let __v_316: G = (__v_159 + __v_315);
+                    let __v_317: G = G::from_u64(256);
+                    let __v_318: G = (__v_317 * __v_174);
+                    let __v_319: G = G::from_u64(65536);
+                    let __v_320: G = (__v_319 * __v_175);
+                    let __v_321: G = G::from_u64(16777216);
+                    let __v_322: G = (__v_321 * __v_176);
+                    let __v_323: G = G::from_u64(4294967296);
+                    let __v_324: G = (__v_323 * __v_177);
+                    let __v_325: G = G::from_u64(1099511627776);
+                    let __v_326: G = (__v_325 * __v_178);
+                    let __v_327: G = G::from_u64(281474976710656);
+                    let __v_328: G = (__v_327 * __v_179);
+                    let __v_329: G = G::from_u64(72057594037927936);
+                    let __v_330: G = (__v_329 * __v_180);
+                    let __v_331: G = (__v_328 + __v_330);
+                    let __v_332: G = (__v_326 + __v_331);
+                    let __v_333: G = (__v_324 + __v_332);
+                    let __v_334: G = (__v_322 + __v_333);
+                    let __v_335: G = (__v_320 + __v_334);
+                    let __v_336: G = (__v_318 + __v_335);
+                    let __v_337: G = (__v_173 + __v_336);
+                    let __v_338: G = G::from_u64(256);
+                    let __v_339: G = (__v_338 * __v_182);
+                    let __v_340: G = G::from_u64(65536);
+                    let __v_341: G = (__v_340 * __v_183);
+                    let __v_342: G = G::from_u64(16777216);
+                    let __v_343: G = (__v_342 * __v_184);
+                    let __v_344: G = G::from_u64(4294967296);
+                    let __v_345: G = (__v_344 * __v_185);
+                    let __v_346: G = G::from_u64(1099511627776);
+                    let __v_347: G = (__v_346 * __v_186);
+                    let __v_348: G = G::from_u64(281474976710656);
+                    let __v_349: G = (__v_348 * __v_187);
+                    let __v_350: G = G::from_u64(72057594037927936);
+                    let __v_351: G = (__v_350 * __v_188);
+                    let __v_352: G = (__v_349 + __v_351);
+                    let __v_353: G = (__v_347 + __v_352);
+                    let __v_354: G = (__v_345 + __v_353);
+                    let __v_355: G = (__v_343 + __v_354);
+                    let __v_356: G = (__v_341 + __v_355);
+                    let __v_357: G = (__v_339 + __v_356);
+                    let __v_358: G = (__v_181 + __v_357);
                     let __v_359: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_358, __v_359, __v_35, __v_210, __v_231, __v_252, __v_273]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
-                    let __v_360: G = __r_arr[0];
-                    let __v_361: G = __r_arr[1];
-                    let __v_362: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_37, __v_38, __v_17, __v_16, __v_33, __v_34, __v_31, __v_32, __v_30, __v_362, __v_360, __v_361, __v_210, __v_231, __v_252, __v_273, __v_294, __v_315, __v_336, __v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
-                    let __v_363: G = __r_arr[0];
-                    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+                    let __v_360: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_359, __v_360, __v_36, __v_211, __v_232, __v_253, __v_274]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
+                    let __v_361: G = __r_arr[0];
+                    let __v_362: G = __r_arr[1];
+                    let __v_363: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_38, __v_39, __v_17, __v_16, __v_34, __v_35, __v_32, __v_33, __v_31, __v_363, __v_361, __v_362, __v_211, __v_232, __v_253, __v_274, __v_295, __v_316, __v_337, __v_358]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
                     let __v_364: G = __r_arr[0];
+                    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
+                    let __v_365: G = __r_arr[0];
                     match __v_18.as_canonical_u64() {
                       _ => {
-                        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                        let __v_365: G = __r_arr[0];
-                        let __v_366: G = G::from_u64(1);
+                        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+                        let __v_366: G = __r_arr[0];
                         let __v_367: G = G::from_u64(1);
-                        let __v_368: G = { let __values: [G; 3] = [__v_366, __v_367, __v_367]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_31.as_canonical_u64() {
+                        let __v_368: G = G::from_u64(1);
+                        let __v_369: G = { let __values: [G; 3] = [__v_367, __v_368, __v_368]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_32.as_canonical_u64() {
   0u64 => {
-    break '__mc_1 [__v_368];
+    break '__mc_1 [__v_369];
   },
   1u64 => {
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_32, __v_368]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-    let __v_369: G = __r_arr[0];
-    break '__mc_1 [__v_369];
+    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_33, __v_369]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_370: G = __r_arr[0];
+    break '__mc_1 [__v_370];
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
+    return Err(ExecError::MatchNoCase(__v_32.as_canonical_u64()));
   },
 }
  };
-                        let __v_369: G = __mc_out___mc_1[0];
-                        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_30, __v_369]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-                        let __v_370: G = __r_arr[0];
-                        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_34, __v_370]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                        let __v_370: G = __mc_out___mc_1[0];
+                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_31, __v_370]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_371: G = __r_arr[0];
-                        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_33, __v_371]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_35, __v_371]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_372: G = __r_arr[0];
-                        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_188, __v_372]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_34, __v_372]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_373: G = __r_arr[0];
-                        let __v_374: G = G::from_u64(1);
+                        let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_189, __v_373]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
+                        let __v_374: G = __r_arr[0];
                         let __v_375: G = G::from_u64(1);
-                        let __v_376: G = { let __values: [G; 3] = [__v_374, __v_375, __v_375]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_373, __v_376]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                        let __v_377: G = __r_arr[0];
-                        let __v_378: G = __r_arr[1];
-                        let __v_379: G = __r_arr[2];
-                        let __v_380: G = __r_arr[3];
-                        let __v_381: G = __r_arr[4];
-                        let __v_382: G = __r_arr[5];
-                        let __v_383: G = __r_arr[6];
-                        let __v_384: G = __r_arr[7];
-                        let __v_385: G = __r_arr[8];
-                        let __v_386: G = __r_arr[9];
-                        let __v_387: G = __r_arr[10];
-                        let __v_388: G = __r_arr[11];
-                        let __v_389: G = __r_arr[12];
-                        let __v_390: G = __r_arr[13];
-                        let __v_391: G = __r_arr[14];
-                        let __v_392: G = __r_arr[15];
-                        let __v_393: G = __r_arr[16];
-                        let __v_394: G = __r_arr[17];
-                        let __v_395: G = G::from_u64(256);
-                        let __v_396: G = (__v_395 * __v_378);
-                        let __v_397: G = G::from_u64(65536);
-                        let __v_398: G = (__v_397 * __v_379);
-                        let __v_399: G = G::from_u64(16777216);
-                        let __v_400: G = (__v_399 * __v_380);
-                        let __v_401: G = G::from_u64(4294967296);
-                        let __v_402: G = (__v_401 * __v_381);
-                        let __v_403: G = G::from_u64(1099511627776);
-                        let __v_404: G = (__v_403 * __v_382);
-                        let __v_405: G = G::from_u64(281474976710656);
-                        let __v_406: G = (__v_405 * __v_383);
-                        let __v_407: G = G::from_u64(72057594037927936);
-                        let __v_408: G = (__v_407 * __v_384);
-                        let __v_409: G = (__v_406 + __v_408);
-                        let __v_410: G = (__v_404 + __v_409);
-                        let __v_411: G = (__v_402 + __v_410);
-                        let __v_412: G = (__v_400 + __v_411);
-                        let __v_413: G = (__v_398 + __v_412);
-                        let __v_414: G = (__v_396 + __v_413);
-                        let __v_415: G = (__v_377 + __v_414);
-                        let __v_416: G = G::from_u64(256);
-                        let __v_417: G = (__v_416 * __v_386);
-                        let __v_418: G = G::from_u64(65536);
-                        let __v_419: G = (__v_418 * __v_387);
-                        let __v_420: G = G::from_u64(16777216);
-                        let __v_421: G = (__v_420 * __v_388);
-                        let __v_422: G = G::from_u64(4294967296);
-                        let __v_423: G = (__v_422 * __v_389);
-                        let __v_424: G = G::from_u64(1099511627776);
-                        let __v_425: G = (__v_424 * __v_390);
-                        let __v_426: G = G::from_u64(281474976710656);
-                        let __v_427: G = (__v_426 * __v_391);
-                        let __v_428: G = G::from_u64(72057594037927936);
-                        let __v_429: G = (__v_428 * __v_392);
-                        let __v_430: G = (__v_427 + __v_429);
-                        let __v_431: G = (__v_425 + __v_430);
-                        let __v_432: G = (__v_423 + __v_431);
-                        let __v_433: G = (__v_421 + __v_432);
-                        let __v_434: G = (__v_419 + __v_433);
-                        let __v_435: G = (__v_417 + __v_434);
-                        let __v_436: G = (__v_385 + __v_435);
-                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_393, __v_18, __v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
-                        let __v_437: G = __r_arr[0];
-                        let __v_438: G = __r_arr[1];
-                        let __v_439: G = G::from_u64(1);
+                        let __v_376: G = G::from_u64(1);
+                        let __v_377: G = { let __values: [G; 3] = [__v_375, __v_376, __v_376]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_374, __v_377]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                        let __v_378: G = __r_arr[0];
+                        let __v_379: G = __r_arr[1];
+                        let __v_380: G = __r_arr[2];
+                        let __v_381: G = __r_arr[3];
+                        let __v_382: G = __r_arr[4];
+                        let __v_383: G = __r_arr[5];
+                        let __v_384: G = __r_arr[6];
+                        let __v_385: G = __r_arr[7];
+                        let __v_386: G = __r_arr[8];
+                        let __v_387: G = __r_arr[9];
+                        let __v_388: G = __r_arr[10];
+                        let __v_389: G = __r_arr[11];
+                        let __v_390: G = __r_arr[12];
+                        let __v_391: G = __r_arr[13];
+                        let __v_392: G = __r_arr[14];
+                        let __v_393: G = __r_arr[15];
+                        let __v_394: G = __r_arr[16];
+                        let __v_395: G = __r_arr[17];
+                        let __v_396: G = G::from_u64(256);
+                        let __v_397: G = (__v_396 * __v_379);
+                        let __v_398: G = G::from_u64(65536);
+                        let __v_399: G = (__v_398 * __v_380);
+                        let __v_400: G = G::from_u64(16777216);
+                        let __v_401: G = (__v_400 * __v_381);
+                        let __v_402: G = G::from_u64(4294967296);
+                        let __v_403: G = (__v_402 * __v_382);
+                        let __v_404: G = G::from_u64(1099511627776);
+                        let __v_405: G = (__v_404 * __v_383);
+                        let __v_406: G = G::from_u64(281474976710656);
+                        let __v_407: G = (__v_406 * __v_384);
+                        let __v_408: G = G::from_u64(72057594037927936);
+                        let __v_409: G = (__v_408 * __v_385);
+                        let __v_410: G = (__v_407 + __v_409);
+                        let __v_411: G = (__v_405 + __v_410);
+                        let __v_412: G = (__v_403 + __v_411);
+                        let __v_413: G = (__v_401 + __v_412);
+                        let __v_414: G = (__v_399 + __v_413);
+                        let __v_415: G = (__v_397 + __v_414);
+                        let __v_416: G = (__v_378 + __v_415);
+                        let __v_417: G = G::from_u64(256);
+                        let __v_418: G = (__v_417 * __v_387);
+                        let __v_419: G = G::from_u64(65536);
+                        let __v_420: G = (__v_419 * __v_388);
+                        let __v_421: G = G::from_u64(16777216);
+                        let __v_422: G = (__v_421 * __v_389);
+                        let __v_423: G = G::from_u64(4294967296);
+                        let __v_424: G = (__v_423 * __v_390);
+                        let __v_425: G = G::from_u64(1099511627776);
+                        let __v_426: G = (__v_425 * __v_391);
+                        let __v_427: G = G::from_u64(281474976710656);
+                        let __v_428: G = (__v_427 * __v_392);
+                        let __v_429: G = G::from_u64(72057594037927936);
+                        let __v_430: G = (__v_429 * __v_393);
+                        let __v_431: G = (__v_428 + __v_430);
+                        let __v_432: G = (__v_426 + __v_431);
+                        let __v_433: G = (__v_424 + __v_432);
+                        let __v_434: G = (__v_422 + __v_433);
+                        let __v_435: G = (__v_420 + __v_434);
+                        let __v_436: G = (__v_418 + __v_435);
+                        let __v_437: G = (__v_386 + __v_436);
+                        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_394, __v_18, __v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } };
+                        let __v_438: G = __r_arr[0];
+                        let __v_439: G = __r_arr[1];
                         let __v_440: G = G::from_u64(1);
-                        let __v_441: G = { let __values: [G; 3] = [__v_439, __v_440, __v_440]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_21, __v_441]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_442: G = __r_arr[0];
-                        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_438, __v_442]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+                        let __v_441: G = G::from_u64(1);
+                        let __v_442: G = { let __values: [G; 3] = [__v_440, __v_441, __v_441]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_22, __v_442]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
                         let __v_443: G = __r_arr[0];
-                        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_443, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_439, __v_443]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
                         let __v_444: G = __r_arr[0];
-                        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_444, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_444, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
                         let __v_445: G = __r_arr[0];
-                        let __v_446: G = __r_arr[1];
-                        let __v_447: G = (__v_365 + __v_0);
-                        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
-                        let __v_448: G = __r_arr[0];
-                        let __v_449: G = G::from_u64(1);
-                        if (__v_448 != __v_449) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_448.as_canonical_u64(), rhs: __v_449.as_canonical_u64(), msg: None });
-                        }
-                        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                        let __v_450: G = __r_arr[0];
-                        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_445, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_446: G = __r_arr[0];
+                        let __v_447: G = __r_arr[1];
+                        let __v_448: G = (__v_366 + __v_0);
+                        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_446, __v_447, __v_4, __v_448]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+                        let __v_449: G = __r_arr[0];
+                        let __v_450: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_20, __v_21, __v_450, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
                         let __v_451: G = __r_arr[0];
-                        let __v_452: G = (__v_450 - __v_451);
-                        let __v_453: G = G::from_bool((__v_452 == G::ZERO));
-                        let __v_454: G = G::from_u64(1);
-                        if (__v_453 != __v_454) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_453.as_canonical_u64(), rhs: __v_454.as_canonical_u64(), msg: None });
+                        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_446, __v_447, __v_451, __v_416, __v_437, __v_34, __v_35, __v_31, __v_32, __v_33, __v_13, __v_14, __v_15, __v_40, __v_39, __v_17, __v_337, __v_358, __v_365, __v_0, __v_448, __v_438, __v_18, __v_22, __v_366]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+                        let __v_452: G = __r_arr[0];
+                        let __v_453: G = G::from_u64(0);
+                        if (__v_1 != __v_453) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_453.as_canonical_u64(), msg: None });
+                        }
+                        let __v_454: G = G::from_u64(0);
+                        if (__v_2 != __v_454) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_454.as_canonical_u64(), msg: None });
                         }
-                        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
-                        let __v_455: 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                        let __v_455: G = G::from_u64(1);
+                        if (__v_3 != __v_455) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_455.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
                         let __v_456: G = __r_arr[0];
-                        let __v_457: G = (__v_455 - __v_456);
-                        let __v_458: G = G::from_bool((__v_457 == G::ZERO));
-                        let __v_459: G = G::from_u64(1);
-                        if (__v_458 != __v_459) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_458.as_canonical_u64(), rhs: __v_459.as_canonical_u64(), msg: None });
+                        let __v_457: G = G::from_u64(1);
+                        if (__v_456 != __v_457) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_456.as_canonical_u64(), rhs: __v_457.as_canonical_u64(), msg: None });
                         }
-                        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
-                        let __v_460: G = __r_arr[0];
-                        let __v_461: G = (__v_460 - __v_365);
-                        let __v_462: G = G::from_bool((__v_461 == G::ZERO));
-                        let __v_463: G = G::from_u64(1);
-                        if (__v_462 != __v_463) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_462.as_canonical_u64(), rhs: __v_463.as_canonical_u64(), msg: None });
+                        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+                        let __v_458: G = __r_arr[0];
+                        let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
+                        let __v_459: G = __r_arr[0];
+                        let __v_460: G = (__v_458 - __v_459);
+                        let __v_461: G = G::from_bool((__v_460 == G::ZERO));
+                        let __v_462: G = G::from_u64(1);
+                        if (__v_461 != __v_462) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_461.as_canonical_u64(), rhs: __v_462.as_canonical_u64(), msg: None });
                         }
-                        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
+                        let __v_463: G = __r_arr[0];
+                        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
                         let __v_464: G = __r_arr[0];
-                        let __v_465: G = (__v_464 - __v_4);
+                        let __v_465: G = (__v_463 - __v_464);
                         let __v_466: G = G::from_bool((__v_465 == G::ZERO));
                         let __v_467: G = G::from_u64(1);
                         if (__v_466 != __v_467) {
                           return Err(ExecError::AssertEqMismatch { lhs: __v_466.as_canonical_u64(), rhs: __v_467.as_canonical_u64(), msg: None });
                         }
-                        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
                         let __v_468: G = __r_arr[0];
-                        let __v_469: G = G::from_u64(1);
-                        if (__v_468 != __v_469) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_468.as_canonical_u64(), rhs: __v_469.as_canonical_u64(), msg: None });
+                        let __v_469: G = (__v_468 - __v_366);
+                        let __v_470: G = G::from_bool((__v_469 == G::ZERO));
+                        let __v_471: G = G::from_u64(1);
+                        if (__v_470 != __v_471) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_470.as_canonical_u64(), rhs: __v_471.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+                        let __v_472: G = __r_arr[0];
+                        let __v_473: G = G::from_u64(3);
+                        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+                        let __v_474: G = __r_arr[0];
+                        let __v_475: G = (__v_473 + __v_474);
+                        if (__v_472 != __v_475) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_472.as_canonical_u64(), rhs: __v_475.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
+                        let __v_476: G = __r_arr[0];
+                        let __v_477: G = (__v_476 - __v_366);
+                        let __v_478: G = G::from_bool((__v_477 == G::ZERO));
+                        let __v_479: G = G::from_u64(1);
+                        if (__v_478 != __v_479) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_478.as_canonical_u64(), rhs: __v_479.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+                        let __v_480: G = __r_arr[0];
+                        let __v_481: G = G::from_u64(1);
+                        if (__v_480 != __v_481) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_481.as_canonical_u64(), msg: None });
                         }
-                        let __v_470: G = G::from_u64(33);
-                        let __v_471: G = { let __a_val = __v_447.as_canonical_u64(); let __b_val = __v_470.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                        let __v_472: G = G::from_u64(1);
-                        if (__v_471 != __v_472) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_471.as_canonical_u64(), rhs: __v_472.as_canonical_u64(), msg: None });
+                        let __v_482: G = G::from_u64(33);
+                        let __v_483: G = { let __a_val = __v_448.as_canonical_u64(); let __b_val = __v_482.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                        let __v_484: G = G::from_u64(1);
+                        if (__v_483 != __v_484) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_483.as_canonical_u64(), rhs: __v_484.as_canonical_u64(), msg: None });
                         }
-                        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_445, __v_446, __v_20, __v_415, __v_436, __v_33, __v_34, __v_30, __v_31, __v_32, __v_13, __v_14, __v_15, __v_39, __v_38, __v_17, __v_336, __v_357, __v_364, __v_0, __v_447, __v_437, __v_18, __v_21, __v_365]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { 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_473: G = __r_arr[0];
-                        let __ret: [G; OUT_183] = [__v_473];
-                        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_20, __v_449, __v_13, __v_14, __v_15, __v_40, __v_32, __v_33, __v_39, __v_17, __v_365, __v_0, __v_448]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+                        let __v_485: G = __r_arr[0];
+                        let __v_486: G = G::from_u64(1);
+                        if (__v_485 != __v_486) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_485.as_canonical_u64(), rhs: __v_486.as_canonical_u64(), msg: None });
+                        }
+                        let __v_487: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_21, __v_18, __v_452, __v_449, __v_487, __v_448]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
+                        let __v_488: G = __r_arr[0];
+                        let __ret: [G; OUT_196] = [__v_488];
+                        if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                         return Ok(__ret);
                       },
                     }
@@ -17875,16 +18889,16 @@ fn aiur_fn_183(
     }
   })
 }
-
-const INPUT_SIZE_184: usize = 1;
-const IN_184: usize = 1;
-const OUT_184: usize = 1;
-fn aiur_fn_184(
-  inp: [G; IN_184],
+
+const INPUT_SIZE_197: usize = 1;
+const IN_197: usize = 1;
+const OUT_197: usize = 1;
+fn aiur_fn_197(
+  inp: [G; IN_197],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_184], ExecError> {
+) -> Result<[G; OUT_197], 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 };
@@ -17894,8 +18908,8 @@ fn aiur_fn_184(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_184] = [__v_4];
-        if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_197] = [__v_4];
+        if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -17906,10 +18920,10 @@ fn aiur_fn_184(
         if (__v_6 != __v_7) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_184] = [__v_8];
-        if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_197] = [__v_8];
+        if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -17919,15 +18933,15 @@ fn aiur_fn_184(
   })
 }
 
-const INPUT_SIZE_185: usize = 2;
-const IN_185: usize = 2;
-const OUT_185: usize = 1;
-fn aiur_fn_185(
-  inp: [G; IN_185],
+const INPUT_SIZE_198: usize = 2;
+const IN_198: usize = 2;
+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_185], ExecError> {
+) -> Result<[G; OUT_198], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -17945,8 +18959,8 @@ 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; 8] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_185] = [__v_12];
-        if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_198] = [__v_12];
+        if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -17958,19 +18972,19 @@ fn aiur_fn_185(
           0u64 => {
             match __v_11.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
-                let __ret: [G; OUT_185] = [__v_13];
-                if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_198] = [__v_13];
+                if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_13: G = G::from_u64(0);
-                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = { let __values: [G; 8] = [__v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_185] = [__v_15];
-                if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_198] = [__v_15];
+                if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -17987,15 +19001,15 @@ fn aiur_fn_185(
   })
 }
 
-const INPUT_SIZE_186: usize = 2;
-const IN_186: usize = 2;
-const OUT_186: usize = 1;
-fn aiur_fn_186(
-  inp: [G; IN_186],
+const INPUT_SIZE_199: usize = 2;
+const IN_199: usize = 2;
+const OUT_199: usize = 1;
+fn aiur_fn_199(
+  inp: [G; IN_199],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_186], ExecError> {
+) -> Result<[G; OUT_199], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18009,8 +19023,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];
-        if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_199] = [__v_8];
+        if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
@@ -18022,19 +19036,19 @@ fn aiur_fn_186(
           0u64 => {
             match __v_7.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_186] = [__v_9];
-                if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_199] = [__v_9];
+                if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
                 let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_186] = [__v_11];
-                if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_199] = [__v_11];
+                if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
                 return Ok(__ret);
               },
             }
@@ -18051,38 +19065,38 @@ fn aiur_fn_186(
   })
 }
 
-const INPUT_SIZE_187: usize = 1;
-const IN_187: usize = 1;
-const OUT_187: usize = 2;
-fn aiur_fn_187(
-  inp: [G; IN_187],
+const INPUT_SIZE_200: usize = 1;
+const IN_200: usize = 1;
+const OUT_200: usize = 2;
+fn aiur_fn_200(
+  inp: [G; IN_200],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_187], ExecError> {
+) -> Result<[G; OUT_200], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { 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_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_187] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_200] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_188: usize = 2;
-const IN_188: usize = 2;
-const OUT_188: usize = 2;
-fn aiur_fn_188(
-  inp: [G; IN_188],
+const INPUT_SIZE_201: usize = 2;
+const IN_201: usize = 2;
+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_188], ExecError> {
+) -> Result<[G; OUT_201], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -18091,64 +19105,64 @@ fn aiur_fn_188(
         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_188] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_201] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { 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_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
-        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
         let __v_6: G = G::from_u64(1);
         let __v_7: G = (__v_1 - __v_6);
-        let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         let __v_10: G = G::from_u64(0);
         let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __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_188] = [__v_11, __v_9];
-        if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_201] = [__v_11, __v_9];
+        if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_189: usize = 1;
-const IN_189: usize = 1;
-const OUT_189: usize = 2;
-fn aiur_fn_189(
-  inp: [G; IN_189],
+const INPUT_SIZE_202: usize = 1;
+const IN_202: usize = 1;
+const OUT_202: usize = 2;
+fn aiur_fn_202(
+  inp: [G; IN_202],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_189], ExecError> {
+) -> Result<[G; OUT_202], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { 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_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_189] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_202] = [__v_3, __v_4];
+    if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_190: usize = 2;
-const IN_190: usize = 2;
-const OUT_190: usize = 2;
-fn aiur_fn_190(
-  inp: [G; IN_190],
+const INPUT_SIZE_203: usize = 2;
+const IN_203: usize = 2;
+const OUT_203: usize = 2;
+fn aiur_fn_203(
+  inp: [G; IN_203],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_190], 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];
@@ -18157,12 +19171,12 @@ fn aiur_fn_190(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_190] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_203] = [__v_4, __v_0];
+        if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { 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_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -18174,28 +19188,28 @@ fn aiur_fn_190(
         let __v_10: G = __r_arr[8];
         let __v_11: G = G::from_u64(1);
         let __v_12: G = (__v_1 - __v_11);
-        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
         let __v_15: G = G::from_u64(0);
         let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_190] = [__v_16, __v_14];
-        if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_203] = [__v_16, __v_14];
+        if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_191: usize = 16;
-const IN_191: usize = 16;
-const OUT_191: usize = 0;
-fn aiur_fn_191(
-  inp: [G; IN_191],
+const INPUT_SIZE_204: usize = 16;
+const IN_204: usize = 16;
+const OUT_204: usize = 0;
+fn aiur_fn_204(
+  inp: [G; IN_204],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_191], 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];
@@ -18218,961 +19232,1002 @@ fn aiur_fn_191(
     let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_16, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
     let __v_18: G = __io_pair.0;
     let __v_19: G = __io_pair.1;
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_20: G = __r_arr[0];
     let __v_21: G = __r_arr[1];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_21, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { 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_32] = { let __args: [G; IN_32] = [__v_21, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
     let __v_22: G = __r_arr[0];
     let __v_23: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_24: G = __r_arr[0];
     let __v_25: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { 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_26: G = __r_arr[0];
     let __v_27: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { 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_37] = { let __args: [G; IN_37] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
     let __v_28: G = __r_arr[0];
     let __v_29: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_35] = { let __args: [G; IN_35] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_30: G = __r_arr[0];
     let __v_31: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_32: G = __r_arr[0];
     let __v_33: G = __r_arr[1];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { 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_32] = { let __args: [G; IN_32] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_34: G = __r_arr[0];
     let __v_35: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_36: G = __r_arr[0];
     let __v_37: G = __r_arr[1];
-    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_37, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { 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_37, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { 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_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
-    let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { 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_33] = { let __args: [G; IN_33] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
     let __v_40: G = __r_arr[0];
     let __v_41: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_42: G = __r_arr[0];
     let __v_43: G = __r_arr[1];
-    let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_43, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { 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_53] = { let __args: [G; IN_53] = [__v_43, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { 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_44: G = __r_arr[0];
     let __v_45: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { 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_28] = { let __args: [G; IN_28] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { 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_46: G = __r_arr[0];
     let __v_47: G = __r_arr[1];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_47]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { 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_56] = { let __args: [G; IN_56] = [__v_47, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
     let __v_48: G = __r_arr[0];
     let __v_49: G = __r_arr[1];
-    let __v_50: G = __r_arr[2];
-    let __v_51: G = __r_arr[3];
-    let __v_52: G = __r_arr[4];
-    let __v_53: G = __r_arr[5];
-    let __v_54: G = __r_arr[6];
-    let __v_55: G = __r_arr[7];
-    let __v_56: G = __r_arr[8];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { 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_57: G = __r_arr[0];
-    let __v_58: G = __r_arr[1];
-    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { 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_59: G = __r_arr[0];
-    let __v_60: G = __r_arr[1];
-    let __v_61: G = __r_arr[2];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { 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_62: G = __r_arr[0];
-    let __v_63: G = __r_arr[1];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { 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_64: G = __r_arr[0];
-    let __v_65: G = __r_arr[1];
-    let __v_66: G = G::from_u64(1);
-    let __v_67: G = G::from_u64(0);
-    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_67]; let __info = io_buffer.get_info(__v_66, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
-    let __v_68: G = __io_pair.0;
-    let __v_69: G = __io_pair.1;
+    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { 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_50: G = __r_arr[0];
+    let __v_51: G = __r_arr[1];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_51]; let __cu = true; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { 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_52: G = __r_arr[0];
+    let __v_53: G = __r_arr[1];
+    let __v_54: G = __r_arr[2];
+    let __v_55: G = __r_arr[3];
+    let __v_56: G = __r_arr[4];
+    let __v_57: G = __r_arr[5];
+    let __v_58: G = __r_arr[6];
+    let __v_59: G = __r_arr[7];
+    let __v_60: G = __r_arr[8];
+    let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { 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_61: G = __r_arr[0];
+    let __v_62: G = __r_arr[1];
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { 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_63: G = __r_arr[0];
+    let __v_64: G = __r_arr[1];
+    let __v_65: G = __r_arr[2];
+    let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { 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_66: G = __r_arr[0];
+    let __v_67: G = __r_arr[1];
+    let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { 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_68: G = __r_arr[0];
+    let __v_69: G = __r_arr[1];
     let __v_70: G = G::from_u64(1);
-    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_70, __v_68, __v_69]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { 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_71: G = __r_arr[0];
-    let __v_72: G = G::from_u64(103);
-    let __v_73: G = G::from_u64(230);
-    let __v_74: G = G::from_u64(9);
-    let __v_75: G = G::from_u64(106);
-    let __v_76: G = G::from_u64(133);
-    let __v_77: G = G::from_u64(174);
-    let __v_78: G = G::from_u64(103);
-    let __v_79: G = G::from_u64(187);
-    let __v_80: G = G::from_u64(114);
-    let __v_81: G = G::from_u64(243);
-    let __v_82: G = G::from_u64(110);
-    let __v_83: G = G::from_u64(60);
-    let __v_84: G = G::from_u64(58);
-    let __v_85: G = G::from_u64(245);
-    let __v_86: G = G::from_u64(79);
-    let __v_87: G = G::from_u64(165);
-    let __v_88: G = G::from_u64(127);
-    let __v_89: G = G::from_u64(82);
-    let __v_90: G = G::from_u64(14);
-    let __v_91: G = G::from_u64(81);
-    let __v_92: G = G::from_u64(140);
-    let __v_93: G = G::from_u64(104);
-    let __v_94: G = G::from_u64(5);
-    let __v_95: G = G::from_u64(155);
-    let __v_96: G = G::from_u64(171);
-    let __v_97: G = G::from_u64(217);
-    let __v_98: G = G::from_u64(131);
-    let __v_99: G = G::from_u64(31);
-    let __v_100: G = G::from_u64(25);
-    let __v_101: G = G::from_u64(205);
-    let __v_102: G = G::from_u64(224);
-    let __v_103: G = G::from_u64(91);
-    let __v_104: G = G::from_u64(1);
-    let __v_105: G = G::from_u64(1);
-    let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_107: G = G::from_u64(0);
-    let __v_108: G = G::from_u64(0);
-    let __v_109: G = G::from_u64(0);
-    let __v_110: G = G::from_u64(0);
+    let __v_71: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_71]; let __info = io_buffer.get_info(__v_70, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_72: G = __io_pair.0;
+    let __v_73: G = __io_pair.1;
+    let __v_74: G = G::from_u64(1);
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_74, __v_72, __v_73]; let __cu = true; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __v_75: G = __r_arr[0];
+    let __v_76: G = G::from_u64(103);
+    let __v_77: G = G::from_u64(230);
+    let __v_78: G = G::from_u64(9);
+    let __v_79: G = G::from_u64(106);
+    let __v_80: G = G::from_u64(133);
+    let __v_81: G = G::from_u64(174);
+    let __v_82: G = G::from_u64(103);
+    let __v_83: G = G::from_u64(187);
+    let __v_84: G = G::from_u64(114);
+    let __v_85: G = G::from_u64(243);
+    let __v_86: G = G::from_u64(110);
+    let __v_87: G = G::from_u64(60);
+    let __v_88: G = G::from_u64(58);
+    let __v_89: G = G::from_u64(245);
+    let __v_90: G = G::from_u64(79);
+    let __v_91: G = G::from_u64(165);
+    let __v_92: G = G::from_u64(127);
+    let __v_93: G = G::from_u64(82);
+    let __v_94: G = G::from_u64(14);
+    let __v_95: G = G::from_u64(81);
+    let __v_96: G = G::from_u64(140);
+    let __v_97: G = G::from_u64(104);
+    let __v_98: G = G::from_u64(5);
+    let __v_99: G = G::from_u64(155);
+    let __v_100: G = G::from_u64(171);
+    let __v_101: G = G::from_u64(217);
+    let __v_102: G = G::from_u64(131);
+    let __v_103: G = G::from_u64(31);
+    let __v_104: G = G::from_u64(25);
+    let __v_105: G = G::from_u64(205);
+    let __v_106: G = G::from_u64(224);
+    let __v_107: G = G::from_u64(91);
+    let __v_108: G = G::from_u64(1);
+    let __v_109: G = G::from_u64(1);
+    let __v_110: G = { let __values: [G; 3] = [__v_108, __v_109, __v_109]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_111: G = G::from_u64(0);
     let __v_112: G = G::from_u64(0);
     let __v_113: G = G::from_u64(0);
     let __v_114: G = G::from_u64(0);
     let __v_115: G = G::from_u64(0);
     let __v_116: G = G::from_u64(0);
-    let __v_117: G = { let __values: [G; 8] = [__v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; 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_118: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_119: G = G::from_u64(1);
-    let __v_120: G = G::from_u64(1);
-    let __v_121: G = { let __values: [G; 34] = [__v_119, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120]; 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_65] = { let __args: [G; IN_65] = [__v_71, __v_106, __v_107, __v_108, __v_117, __v_118, __v_121]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { 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_122: G = __r_arr[0];
-    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { 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_123: G = __r_arr[0];
-    let __v_124: G = __r_arr[1];
-    let __v_125: G = __r_arr[2];
-    let __v_126: G = __r_arr[3];
-    let __v_127: G = __r_arr[4];
-    let __v_128: G = __r_arr[5];
-    let __v_129: G = __r_arr[6];
-    let __v_130: G = __r_arr[7];
-    let __v_131: G = __r_arr[8];
-    let __v_132: G = __r_arr[9];
-    let __v_133: G = __r_arr[10];
-    let __v_134: G = __r_arr[11];
-    let __v_135: G = __r_arr[12];
-    let __v_136: G = __r_arr[13];
-    let __v_137: G = __r_arr[14];
-    let __v_138: G = __r_arr[15];
-    let __v_139: G = __r_arr[16];
-    let __v_140: G = __r_arr[17];
-    let __v_141: G = __r_arr[18];
-    let __v_142: G = __r_arr[19];
-    let __v_143: G = __r_arr[20];
-    let __v_144: G = __r_arr[21];
-    let __v_145: G = __r_arr[22];
-    let __v_146: G = __r_arr[23];
-    let __v_147: G = __r_arr[24];
-    let __v_148: G = __r_arr[25];
-    let __v_149: G = __r_arr[26];
-    let __v_150: G = __r_arr[27];
-    let __v_151: G = __r_arr[28];
-    let __v_152: G = __r_arr[29];
-    let __v_153: G = __r_arr[30];
-    let __v_154: G = __r_arr[31];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_155: G = __r_arr[0];
-    let __v_156: G = __r_arr[1];
-    let __v_157: G = __r_arr[2];
-    let __v_158: G = __r_arr[3];
-    let __v_159: G = __r_arr[4];
-    let __v_160: G = __r_arr[5];
-    let __v_161: G = __r_arr[6];
-    let __v_162: G = __r_arr[7];
-    let __v_163: G = __r_arr[8];
-    let __v_164: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_164]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_165: G = __r_arr[0];
-    let __v_166: G = __r_arr[1];
-    let __v_167: G = __r_arr[2];
-    let __v_168: G = __r_arr[3];
-    let __v_169: G = __r_arr[4];
-    let __v_170: G = __r_arr[5];
-    let __v_171: G = __r_arr[6];
-    let __v_172: G = __r_arr[7];
-    let __v_173: G = __r_arr[8];
-    let __v_174: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_174]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_175: G = __r_arr[0];
-    let __v_176: G = __r_arr[1];
-    let __v_177: G = __r_arr[2];
-    let __v_178: G = __r_arr[3];
-    let __v_179: G = __r_arr[4];
-    let __v_180: G = __r_arr[5];
-    let __v_181: G = __r_arr[6];
-    let __v_182: G = __r_arr[7];
-    let __v_183: G = __r_arr[8];
-    let __v_184: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_184]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_185: G = __r_arr[0];
-    let __v_186: G = __r_arr[1];
-    let __v_187: G = __r_arr[2];
-    let __v_188: G = __r_arr[3];
-    let __v_189: G = __r_arr[4];
-    let __v_190: G = __r_arr[5];
-    let __v_191: G = __r_arr[6];
-    let __v_192: G = __r_arr[7];
-    let __v_193: G = __r_arr[8];
-    let __v_194: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_194]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_195: G = __r_arr[0];
-    let __v_196: G = __r_arr[1];
-    let __v_197: G = __r_arr[2];
-    let __v_198: G = __r_arr[3];
-    let __v_199: G = __r_arr[4];
-    let __v_200: G = __r_arr[5];
-    let __v_201: G = __r_arr[6];
-    let __v_202: G = __r_arr[7];
-    let __v_203: G = __r_arr[8];
-    let __v_204: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_204]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_205: G = __r_arr[0];
-    let __v_206: G = __r_arr[1];
-    let __v_207: G = __r_arr[2];
-    let __v_208: G = __r_arr[3];
-    let __v_209: G = __r_arr[4];
-    let __v_210: G = __r_arr[5];
-    let __v_211: G = __r_arr[6];
-    let __v_212: G = __r_arr[7];
-    let __v_213: G = __r_arr[8];
-    let __v_214: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_214]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_215: G = __r_arr[0];
-    let __v_216: G = __r_arr[1];
-    let __v_217: G = __r_arr[2];
-    let __v_218: G = __r_arr[3];
-    let __v_219: G = __r_arr[4];
-    let __v_220: G = __r_arr[5];
-    let __v_221: G = __r_arr[6];
-    let __v_222: G = __r_arr[7];
-    let __v_223: G = __r_arr[8];
-    let __v_224: G = __r_arr[9];
-    let __v_225: G = G::from_u64(0);
-    let __v_226: G = G::from_u64(0);
-    let __v_227: G = G::from_u64(0);
-    let __v_228: G = G::from_u64(0);
+    let __v_117: G = G::from_u64(0);
+    let __v_118: G = G::from_u64(0);
+    let __v_119: G = G::from_u64(0);
+    let __v_120: G = G::from_u64(0);
+    let __v_121: G = { let __values: [G; 8] = [__v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120]; 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_122: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_123: G = G::from_u64(1);
+    let __v_124: G = G::from_u64(1);
+    let __v_125: G = { let __values: [G; 34] = [__v_123, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124]; 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_65] = { let __args: [G; IN_65] = [__v_75, __v_110, __v_111, __v_112, __v_121, __v_122, __v_125]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { 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_126: G = __r_arr[0];
+    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_126]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { 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_127: G = __r_arr[0];
+    let __v_128: G = __r_arr[1];
+    let __v_129: G = __r_arr[2];
+    let __v_130: G = __r_arr[3];
+    let __v_131: G = __r_arr[4];
+    let __v_132: G = __r_arr[5];
+    let __v_133: G = __r_arr[6];
+    let __v_134: G = __r_arr[7];
+    let __v_135: G = __r_arr[8];
+    let __v_136: G = __r_arr[9];
+    let __v_137: G = __r_arr[10];
+    let __v_138: G = __r_arr[11];
+    let __v_139: G = __r_arr[12];
+    let __v_140: G = __r_arr[13];
+    let __v_141: G = __r_arr[14];
+    let __v_142: G = __r_arr[15];
+    let __v_143: G = __r_arr[16];
+    let __v_144: G = __r_arr[17];
+    let __v_145: G = __r_arr[18];
+    let __v_146: G = __r_arr[19];
+    let __v_147: G = __r_arr[20];
+    let __v_148: G = __r_arr[21];
+    let __v_149: G = __r_arr[22];
+    let __v_150: G = __r_arr[23];
+    let __v_151: G = __r_arr[24];
+    let __v_152: G = __r_arr[25];
+    let __v_153: G = __r_arr[26];
+    let __v_154: G = __r_arr[27];
+    let __v_155: G = __r_arr[28];
+    let __v_156: G = __r_arr[29];
+    let __v_157: G = __r_arr[30];
+    let __v_158: G = __r_arr[31];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_159: G = __r_arr[0];
+    let __v_160: G = __r_arr[1];
+    let __v_161: G = __r_arr[2];
+    let __v_162: G = __r_arr[3];
+    let __v_163: G = __r_arr[4];
+    let __v_164: G = __r_arr[5];
+    let __v_165: G = __r_arr[6];
+    let __v_166: G = __r_arr[7];
+    let __v_167: G = __r_arr[8];
+    let __v_168: G = __r_arr[9];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_168]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_169: G = __r_arr[0];
+    let __v_170: G = __r_arr[1];
+    let __v_171: G = __r_arr[2];
+    let __v_172: G = __r_arr[3];
+    let __v_173: G = __r_arr[4];
+    let __v_174: G = __r_arr[5];
+    let __v_175: G = __r_arr[6];
+    let __v_176: G = __r_arr[7];
+    let __v_177: G = __r_arr[8];
+    let __v_178: G = __r_arr[9];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_178]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_179: G = __r_arr[0];
+    let __v_180: G = __r_arr[1];
+    let __v_181: G = __r_arr[2];
+    let __v_182: G = __r_arr[3];
+    let __v_183: G = __r_arr[4];
+    let __v_184: G = __r_arr[5];
+    let __v_185: G = __r_arr[6];
+    let __v_186: G = __r_arr[7];
+    let __v_187: G = __r_arr[8];
+    let __v_188: G = __r_arr[9];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_188]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_189: G = __r_arr[0];
+    let __v_190: G = __r_arr[1];
+    let __v_191: G = __r_arr[2];
+    let __v_192: G = __r_arr[3];
+    let __v_193: G = __r_arr[4];
+    let __v_194: G = __r_arr[5];
+    let __v_195: G = __r_arr[6];
+    let __v_196: G = __r_arr[7];
+    let __v_197: G = __r_arr[8];
+    let __v_198: G = __r_arr[9];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_198]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_199: G = __r_arr[0];
+    let __v_200: G = __r_arr[1];
+    let __v_201: G = __r_arr[2];
+    let __v_202: G = __r_arr[3];
+    let __v_203: G = __r_arr[4];
+    let __v_204: G = __r_arr[5];
+    let __v_205: G = __r_arr[6];
+    let __v_206: G = __r_arr[7];
+    let __v_207: G = __r_arr[8];
+    let __v_208: G = __r_arr[9];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_208]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_218]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_219: G = __r_arr[0];
+    let __v_220: G = __r_arr[1];
+    let __v_221: G = __r_arr[2];
+    let __v_222: G = __r_arr[3];
+    let __v_223: G = __r_arr[4];
+    let __v_224: G = __r_arr[5];
+    let __v_225: G = __r_arr[6];
+    let __v_226: G = __r_arr[7];
+    let __v_227: G = __r_arr[8];
+    let __v_228: G = __r_arr[9];
     let __v_229: G = G::from_u64(0);
     let __v_230: G = G::from_u64(0);
     let __v_231: G = G::from_u64(0);
-    let __v_232: G = G::from_u64(1);
-    let __v_233: G = G::from_u64(1);
-    let __v_234: G = { let __values: [G; 10] = [__v_232, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_235: G = { let __values: [G; 10] = [__v_231, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_234]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_236: G = { let __values: [G; 10] = [__v_230, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_235]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_237: G = { let __values: [G; 10] = [__v_229, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_236]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_238: G = { let __values: [G; 10] = [__v_228, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_237]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_239: G = { let __values: [G; 10] = [__v_227, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_238]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_240: G = { let __values: [G; 10] = [__v_226, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_239]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_241: G = { let __values: [G; 10] = [__v_225, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_240]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_224]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_242: G = __r_arr[0];
-    let __v_243: G = __r_arr[1];
-    let __v_244: G = __r_arr[2];
-    let __v_245: G = __r_arr[3];
-    let __v_246: G = __r_arr[4];
-    let __v_247: G = __r_arr[5];
-    let __v_248: G = __r_arr[6];
-    let __v_249: G = __r_arr[7];
-    let __v_250: G = __r_arr[8];
-    let __v_251: G = __r_arr[9];
-    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_251, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { 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_252: G = __r_arr[0];
-    let __v_253: G = __r_arr[1];
-    let __v_254: G = __r_arr[2];
-    let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_254]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { 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_255: G = __r_arr[0];
-    let __v_256: G = __r_arr[1];
-    let __v_257: G = __r_arr[2];
-    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_257, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { 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_258: G = __r_arr[0];
-    let __v_259: G = __r_arr[1];
-    let __v_260: G = G::from_u64(0);
-    let __v_261: G = { let __values: [G; 10] = [__v_260, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249, __v_250, __v_253]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_241, __v_261]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
+    let __v_232: G = G::from_u64(0);
+    let __v_233: G = G::from_u64(0);
+    let __v_234: G = G::from_u64(0);
+    let __v_235: G = G::from_u64(0);
+    let __v_236: G = G::from_u64(1);
+    let __v_237: G = G::from_u64(1);
+    let __v_238: G = { let __values: [G; 10] = [__v_236, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_239: G = { let __values: [G; 10] = [__v_235, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_238]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_240: G = { let __values: [G; 10] = [__v_234, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_239]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_241: G = { let __values: [G; 10] = [__v_233, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_240]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_242: G = { let __values: [G; 10] = [__v_232, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_241]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_243: G = { let __values: [G; 10] = [__v_231, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_242]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_244: G = { let __values: [G; 10] = [__v_230, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_243]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_245: G = { let __values: [G; 10] = [__v_229, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_244]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { 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_246: G = __r_arr[0];
+    let __v_247: G = __r_arr[1];
+    let __v_248: G = __r_arr[2];
+    let __v_249: G = __r_arr[3];
+    let __v_250: G = __r_arr[4];
+    let __v_251: G = __r_arr[5];
+    let __v_252: G = __r_arr[6];
+    let __v_253: G = __r_arr[7];
+    let __v_254: G = __r_arr[8];
+    let __v_255: G = __r_arr[9];
+    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_255, __v_246]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { 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_256: G = __r_arr[0];
+    let __v_257: G = __r_arr[1];
+    let __v_258: G = __r_arr[2];
+    let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_258]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { 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_259: G = __r_arr[0];
+    let __v_260: G = __r_arr[1];
+    let __v_261: G = __r_arr[2];
+    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_261, __v_246]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { 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_262: G = __r_arr[0];
-    let __v_263: G = G::from_u64(2);
+    let __v_263: G = __r_arr[1];
     let __v_264: G = G::from_u64(0);
-    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_264]; let __info = io_buffer.get_info(__v_263, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
-    let __v_265: G = __io_pair.0;
-    let __v_266: G = __io_pair.1;
+    let __v_265: G = { let __values: [G; 10] = [__v_264, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_257]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_245, __v_265]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } };
+    let __v_266: G = __r_arr[0];
     let __v_267: G = G::from_u64(2);
-    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_267, __v_265, __v_266]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { 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_268: G = __r_arr[0];
-    let __v_269: G = G::from_u64(103);
-    let __v_270: G = G::from_u64(230);
-    let __v_271: G = G::from_u64(9);
-    let __v_272: G = G::from_u64(106);
-    let __v_273: G = G::from_u64(133);
-    let __v_274: G = G::from_u64(174);
-    let __v_275: G = G::from_u64(103);
-    let __v_276: G = G::from_u64(187);
-    let __v_277: G = G::from_u64(114);
-    let __v_278: G = G::from_u64(243);
-    let __v_279: G = G::from_u64(110);
-    let __v_280: G = G::from_u64(60);
-    let __v_281: G = G::from_u64(58);
-    let __v_282: G = G::from_u64(245);
-    let __v_283: G = G::from_u64(79);
-    let __v_284: G = G::from_u64(165);
-    let __v_285: G = G::from_u64(127);
-    let __v_286: G = G::from_u64(82);
-    let __v_287: G = G::from_u64(14);
-    let __v_288: G = G::from_u64(81);
-    let __v_289: G = G::from_u64(140);
-    let __v_290: G = G::from_u64(104);
-    let __v_291: G = G::from_u64(5);
-    let __v_292: G = G::from_u64(155);
-    let __v_293: G = G::from_u64(171);
-    let __v_294: G = G::from_u64(217);
-    let __v_295: G = G::from_u64(131);
-    let __v_296: G = G::from_u64(31);
-    let __v_297: G = G::from_u64(25);
-    let __v_298: G = G::from_u64(205);
-    let __v_299: G = G::from_u64(224);
-    let __v_300: G = G::from_u64(91);
-    let __v_301: G = G::from_u64(1);
-    let __v_302: G = G::from_u64(1);
-    let __v_303: G = { let __values: [G; 3] = [__v_301, __v_302, __v_302]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_304: G = G::from_u64(0);
-    let __v_305: G = G::from_u64(0);
-    let __v_306: G = G::from_u64(0);
-    let __v_307: G = G::from_u64(0);
+    let __v_268: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_268]; let __info = io_buffer.get_info(__v_267, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_269: G = __io_pair.0;
+    let __v_270: G = __io_pair.1;
+    let __v_271: G = G::from_u64(2);
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_271, __v_269, __v_270]; let __cu = true; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __v_272: G = __r_arr[0];
+    let __v_273: G = G::from_u64(103);
+    let __v_274: G = G::from_u64(230);
+    let __v_275: G = G::from_u64(9);
+    let __v_276: G = G::from_u64(106);
+    let __v_277: G = G::from_u64(133);
+    let __v_278: G = G::from_u64(174);
+    let __v_279: G = G::from_u64(103);
+    let __v_280: G = G::from_u64(187);
+    let __v_281: G = G::from_u64(114);
+    let __v_282: G = G::from_u64(243);
+    let __v_283: G = G::from_u64(110);
+    let __v_284: G = G::from_u64(60);
+    let __v_285: G = G::from_u64(58);
+    let __v_286: G = G::from_u64(245);
+    let __v_287: G = G::from_u64(79);
+    let __v_288: G = G::from_u64(165);
+    let __v_289: G = G::from_u64(127);
+    let __v_290: G = G::from_u64(82);
+    let __v_291: G = G::from_u64(14);
+    let __v_292: G = G::from_u64(81);
+    let __v_293: G = G::from_u64(140);
+    let __v_294: G = G::from_u64(104);
+    let __v_295: G = G::from_u64(5);
+    let __v_296: G = G::from_u64(155);
+    let __v_297: G = G::from_u64(171);
+    let __v_298: G = G::from_u64(217);
+    let __v_299: G = G::from_u64(131);
+    let __v_300: G = G::from_u64(31);
+    let __v_301: G = G::from_u64(25);
+    let __v_302: G = G::from_u64(205);
+    let __v_303: G = G::from_u64(224);
+    let __v_304: G = G::from_u64(91);
+    let __v_305: G = G::from_u64(1);
+    let __v_306: G = G::from_u64(1);
+    let __v_307: G = { let __values: [G; 3] = [__v_305, __v_306, __v_306]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_308: G = G::from_u64(0);
     let __v_309: G = G::from_u64(0);
     let __v_310: G = G::from_u64(0);
     let __v_311: G = G::from_u64(0);
     let __v_312: G = G::from_u64(0);
     let __v_313: G = G::from_u64(0);
-    let __v_314: G = { let __values: [G; 8] = [__v_306, __v_307, __v_308, __v_309, __v_310, __v_311, __v_312, __v_313]; 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_315: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_316: G = G::from_u64(1);
-    let __v_317: G = G::from_u64(1);
-    let __v_318: G = { let __values: [G; 34] = [__v_316, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317]; 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_65] = { let __args: [G; IN_65] = [__v_268, __v_303, __v_304, __v_305, __v_314, __v_315, __v_318]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { 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_319: G = __r_arr[0];
-    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_319]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { 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_320: G = __r_arr[0];
-    let __v_321: G = __r_arr[1];
-    let __v_322: G = __r_arr[2];
-    let __v_323: G = __r_arr[3];
-    let __v_324: G = __r_arr[4];
-    let __v_325: G = __r_arr[5];
-    let __v_326: G = __r_arr[6];
-    let __v_327: G = __r_arr[7];
-    let __v_328: G = __r_arr[8];
-    let __v_329: G = __r_arr[9];
-    let __v_330: G = __r_arr[10];
-    let __v_331: G = __r_arr[11];
-    let __v_332: G = __r_arr[12];
-    let __v_333: G = __r_arr[13];
-    let __v_334: G = __r_arr[14];
-    let __v_335: G = __r_arr[15];
-    let __v_336: G = __r_arr[16];
-    let __v_337: G = __r_arr[17];
-    let __v_338: G = __r_arr[18];
-    let __v_339: G = __r_arr[19];
-    let __v_340: G = __r_arr[20];
-    let __v_341: G = __r_arr[21];
-    let __v_342: G = __r_arr[22];
-    let __v_343: G = __r_arr[23];
-    let __v_344: G = __r_arr[24];
-    let __v_345: G = __r_arr[25];
-    let __v_346: G = __r_arr[26];
-    let __v_347: G = __r_arr[27];
-    let __v_348: G = __r_arr[28];
-    let __v_349: G = __r_arr[29];
-    let __v_350: G = __r_arr[30];
-    let __v_351: G = __r_arr[31];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_268]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
-    let __v_352: G = __r_arr[0];
-    let __v_353: G = __r_arr[1];
-    let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_353, __v_352]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
-    let __v_354: G = __r_arr[0];
-    let __v_355: G = __r_arr[1];
+    let __v_314: G = G::from_u64(0);
+    let __v_315: G = G::from_u64(0);
+    let __v_316: G = G::from_u64(0);
+    let __v_317: G = G::from_u64(0);
+    let __v_318: G = { let __values: [G; 8] = [__v_310, __v_311, __v_312, __v_313, __v_314, __v_315, __v_316, __v_317]; 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_319: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_320: G = G::from_u64(1);
+    let __v_321: G = G::from_u64(1);
+    let __v_322: G = { let __values: [G; 34] = [__v_320, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321]; 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_65] = { let __args: [G; IN_65] = [__v_272, __v_307, __v_308, __v_309, __v_318, __v_319, __v_322]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { 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_323: G = __r_arr[0];
+    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_323]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { 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_324: G = __r_arr[0];
+    let __v_325: G = __r_arr[1];
+    let __v_326: G = __r_arr[2];
+    let __v_327: G = __r_arr[3];
+    let __v_328: G = __r_arr[4];
+    let __v_329: G = __r_arr[5];
+    let __v_330: G = __r_arr[6];
+    let __v_331: G = __r_arr[7];
+    let __v_332: G = __r_arr[8];
+    let __v_333: G = __r_arr[9];
+    let __v_334: G = __r_arr[10];
+    let __v_335: G = __r_arr[11];
+    let __v_336: G = __r_arr[12];
+    let __v_337: G = __r_arr[13];
+    let __v_338: G = __r_arr[14];
+    let __v_339: G = __r_arr[15];
+    let __v_340: G = __r_arr[16];
+    let __v_341: G = __r_arr[17];
+    let __v_342: G = __r_arr[18];
+    let __v_343: G = __r_arr[19];
+    let __v_344: G = __r_arr[20];
+    let __v_345: G = __r_arr[21];
+    let __v_346: G = __r_arr[22];
+    let __v_347: G = __r_arr[23];
+    let __v_348: G = __r_arr[24];
+    let __v_349: G = __r_arr[25];
+    let __v_350: G = __r_arr[26];
+    let __v_351: G = __r_arr[27];
+    let __v_352: G = __r_arr[28];
+    let __v_353: G = __r_arr[29];
+    let __v_354: G = __r_arr[30];
+    let __v_355: G = __r_arr[31];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_272]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_356: G = __r_arr[0];
+    let __v_357: G = __r_arr[1];
+    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_357, __v_356]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
+    let __v_358: G = __r_arr[0];
+    let __v_359: G = __r_arr[1];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_22.as_canonical_u64() {
   _ => {
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-    let __v_356: G = __r_arr[0];
-    let __v_357: G = G::from_bool((__v_356 == G::ZERO));
-    let __v_358: G = G::from_u64(0);
-    if (__v_357 != __v_358) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_357.as_canonical_u64(), rhs: __v_358.as_canonical_u64(), msg: None });
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+    let __v_360: G = __r_arr[0];
+    let __v_361: G = G::from_bool((__v_360 == G::ZERO));
+    let __v_362: G = G::from_u64(0);
+    if (__v_361 != __v_362) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_362.as_canonical_u64(), msg: None });
     }
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-    let __v_359: G = __r_arr[0];
-    if (__v_359 != __v_356) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_359.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: None });
+    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+    let __v_363: G = __r_arr[0];
+    if (__v_363 != __v_360) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_363.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None });
     }
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-    let __v_360: G = __r_arr[0];
-    if (__v_360 != __v_356) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_360.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: None });
+    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+    let __v_364: G = __r_arr[0];
+    if (__v_364 != __v_360) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_364.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None });
     }
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-    let __v_361: G = __r_arr[0];
-    if (__v_361 != __v_356) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: None });
+    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+    let __v_365: G = __r_arr[0];
+    if (__v_365 != __v_360) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_365.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None });
     }
-    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
-    let __v_362: G = __r_arr[0];
-    let __v_363: G = G::from_u64(1);
-    if (__v_362 != __v_363) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_362.as_canonical_u64(), rhs: __v_363.as_canonical_u64(), msg: None });
+    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+    let __v_366: G = __r_arr[0];
+    let __v_367: G = G::from_u64(1);
+    if (__v_366 != __v_367) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_366.as_canonical_u64(), rhs: __v_367.as_canonical_u64(), msg: None });
     }
-    let __v_364: G = G::from_u64(1);
-    break '__mc_0 [__v_364];
+    let __v_368: G = G::from_u64(1);
+    break '__mc_0 [__v_368];
   },
 }
  };
-    let __v_356: G = __mc_out___mc_0[0];
-    let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_155.as_canonical_u64() {
+    let __v_360: G = __mc_out___mc_0[0];
+    let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_159.as_canonical_u64() {
   _ => {
-    match __v_155.as_canonical_u64() {
+    match __v_159.as_canonical_u64() {
       _ => {
         match __v_22.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_252, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
-            let __v_357: G = __r_arr[0];
-            let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_258, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
-            let __v_358: G = __r_arr[0];
+            let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_256, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+            let __v_361: G = __r_arr[0];
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_262, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+            let __v_362: G = __r_arr[0];
             match __v_24.as_canonical_u64() {
               _ => {
-                let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_255.as_canonical_u64() {
+                let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_259.as_canonical_u64() {
   0u64 => {
-    let __v_359: G = G::from_u64(1);
-    let __v_360: G = G::from_u64(1);
-    let __v_361: G = { let __values: [G; 3] = [__v_359, __v_360, __v_360]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    break '__mc_2 [__v_361];
+    let __v_363: G = G::from_u64(1);
+    let __v_364: G = G::from_u64(1);
+    let __v_365: G = { let __values: [G; 3] = [__v_363, __v_364, __v_364]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    break '__mc_2 [__v_365];
   },
   1u64 => {
-    break '__mc_2 [__v_256];
+    break '__mc_2 [__v_260];
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_255.as_canonical_u64()));
+    return Err(ExecError::MatchNoCase(__v_259.as_canonical_u64()));
   },
 }
  };
-                let __v_359: G = __mc_out___mc_2[0];
-                let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_34, __v_268]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-                let __v_360: G = __r_arr[0];
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_24, __v_360]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-                let __v_361: G = __r_arr[0];
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_359, __v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-                let __v_362: G = __r_arr[0];
-                let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_22, __v_362]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-                let __v_363: G = __r_arr[0];
-                let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_262, __v_363]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+                let __v_363: G = __mc_out___mc_2[0];
+                let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_34, __v_272]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
                 let __v_364: G = __r_arr[0];
-                let __v_365: G = G::from_u64(0);
-                let __v_366: G = G::from_u64(109);
-                let __v_367: G = G::from_u64(0);
-                let __v_368: G = G::from_u64(117);
+                let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_24, __v_364]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+                let __v_365: G = __r_arr[0];
+                let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_363, __v_365]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+                let __v_366: G = __r_arr[0];
+                let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_22, __v_366]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+                let __v_367: G = __r_arr[0];
+                let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_266, __v_367]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+                let __v_368: G = __r_arr[0];
                 let __v_369: G = G::from_u64(0);
-                let __v_370: G = G::from_u64(108);
+                let __v_370: G = G::from_u64(109);
                 let __v_371: G = G::from_u64(0);
-                let __v_372: G = G::from_u64(116);
+                let __v_372: G = G::from_u64(117);
                 let __v_373: G = G::from_u64(0);
-                let __v_374: G = G::from_u64(105);
+                let __v_374: G = G::from_u64(108);
                 let __v_375: G = G::from_u64(0);
-                let __v_376: G = G::from_u64(45);
+                let __v_376: G = G::from_u64(116);
                 let __v_377: G = G::from_u64(0);
-                let __v_378: G = G::from_u64(115);
+                let __v_378: G = G::from_u64(105);
                 let __v_379: G = G::from_u64(0);
-                let __v_380: G = G::from_u64(116);
+                let __v_380: G = G::from_u64(45);
                 let __v_381: G = G::from_u64(0);
-                let __v_382: G = G::from_u64(97);
+                let __v_382: G = G::from_u64(115);
                 let __v_383: G = G::from_u64(0);
-                let __v_384: G = G::from_u64(114);
+                let __v_384: G = G::from_u64(116);
                 let __v_385: G = G::from_u64(0);
-                let __v_386: G = G::from_u64(107);
+                let __v_386: G = G::from_u64(97);
                 let __v_387: G = G::from_u64(0);
-                let __v_388: G = G::from_u64(47);
+                let __v_388: G = G::from_u64(114);
                 let __v_389: G = G::from_u64(0);
-                let __v_390: G = G::from_u64(118);
+                let __v_390: G = G::from_u64(107);
                 let __v_391: G = G::from_u64(0);
-                let __v_392: G = G::from_u64(48);
-                let __v_393: G = { let __values: [G; 3] = [__v_391, __v_392, __v_364]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_394: G = { let __values: [G; 3] = [__v_389, __v_390, __v_393]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_395: G = { let __values: [G; 3] = [__v_387, __v_388, __v_394]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_396: G = { let __values: [G; 3] = [__v_385, __v_386, __v_395]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_397: G = { let __values: [G; 3] = [__v_383, __v_384, __v_396]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_398: G = { let __values: [G; 3] = [__v_381, __v_382, __v_397]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_399: G = { let __values: [G; 3] = [__v_379, __v_380, __v_398]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_400: G = { let __values: [G; 3] = [__v_377, __v_378, __v_399]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_401: G = { let __values: [G; 3] = [__v_375, __v_376, __v_400]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_402: G = { let __values: [G; 3] = [__v_373, __v_374, __v_401]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_403: G = { let __values: [G; 3] = [__v_371, __v_372, __v_402]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_404: G = { let __values: [G; 3] = [__v_369, __v_370, __v_403]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_405: G = { let __values: [G; 3] = [__v_367, __v_368, __v_404]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_406: G = { let __values: [G; 3] = [__v_365, __v_366, __v_405]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_407: G = G::from_u64(1);
-                let __v_408: G = G::from_u64(1);
-                let __v_409: G = { let __values: [G; 3] = [__v_407, __v_408, __v_408]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_406, __v_409]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                let __v_410: G = __r_arr[0];
-                let __v_411: G = __r_arr[1];
-                let __v_412: G = __r_arr[2];
-                let __v_413: G = __r_arr[3];
-                let __v_414: G = __r_arr[4];
-                let __v_415: G = __r_arr[5];
-                let __v_416: G = __r_arr[6];
-                let __v_417: G = __r_arr[7];
-                let __v_418: G = __r_arr[8];
-                let __v_419: G = __r_arr[9];
-                let __v_420: G = __r_arr[10];
-                let __v_421: G = __r_arr[11];
-                let __v_422: G = __r_arr[12];
-                let __v_423: G = __r_arr[13];
-                let __v_424: G = __r_arr[14];
-                let __v_425: G = __r_arr[15];
-                let __v_426: G = __r_arr[16];
-                let __v_427: G = __r_arr[17];
-                let __v_428: G = G::from_u64(1);
-                let __v_429: G = G::from_u64(1);
-                let __v_430: G = { let __values: [G; 3] = [__v_428, __v_429, __v_429]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_430]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                let __v_431: G = __r_arr[0];
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_431]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                let __v_432: G = __r_arr[0];
-                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_426, __v_432]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                let __v_433: G = __r_arr[0];
-                let __v_434: G = G::from_u64(1);
-                let __v_435: G = G::from_u64(1);
-                let __v_436: G = { let __values: [G; 3] = [__v_434, __v_435, __v_435]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_433, __v_436]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+                let __v_392: G = G::from_u64(47);
+                let __v_393: G = G::from_u64(0);
+                let __v_394: G = G::from_u64(118);
+                let __v_395: G = G::from_u64(0);
+                let __v_396: G = G::from_u64(48);
+                let __v_397: G = { let __values: [G; 3] = [__v_395, __v_396, __v_368]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_398: G = { let __values: [G; 3] = [__v_393, __v_394, __v_397]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_399: G = { let __values: [G; 3] = [__v_391, __v_392, __v_398]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_400: G = { let __values: [G; 3] = [__v_389, __v_390, __v_399]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_401: G = { let __values: [G; 3] = [__v_387, __v_388, __v_400]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_402: G = { let __values: [G; 3] = [__v_385, __v_386, __v_401]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_403: G = { let __values: [G; 3] = [__v_383, __v_384, __v_402]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_404: G = { let __values: [G; 3] = [__v_381, __v_382, __v_403]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_405: G = { let __values: [G; 3] = [__v_379, __v_380, __v_404]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_406: G = { let __values: [G; 3] = [__v_377, __v_378, __v_405]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_407: G = { let __values: [G; 3] = [__v_375, __v_376, __v_406]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_408: G = { let __values: [G; 3] = [__v_373, __v_374, __v_407]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_409: G = { let __values: [G; 3] = [__v_371, __v_372, __v_408]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_410: G = { let __values: [G; 3] = [__v_369, __v_370, __v_409]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_411: G = G::from_u64(1);
+                let __v_412: G = G::from_u64(1);
+                let __v_413: G = { let __values: [G; 3] = [__v_411, __v_412, __v_412]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_410, __v_413]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                let __v_414: G = __r_arr[0];
+                let __v_415: G = __r_arr[1];
+                let __v_416: G = __r_arr[2];
+                let __v_417: G = __r_arr[3];
+                let __v_418: G = __r_arr[4];
+                let __v_419: G = __r_arr[5];
+                let __v_420: G = __r_arr[6];
+                let __v_421: G = __r_arr[7];
+                let __v_422: G = __r_arr[8];
+                let __v_423: G = __r_arr[9];
+                let __v_424: G = __r_arr[10];
+                let __v_425: G = __r_arr[11];
+                let __v_426: G = __r_arr[12];
+                let __v_427: G = __r_arr[13];
+                let __v_428: G = __r_arr[14];
+                let __v_429: G = __r_arr[15];
+                let __v_430: G = __r_arr[16];
+                let __v_431: G = __r_arr[17];
+                let __v_432: G = G::from_u64(1);
+                let __v_433: G = G::from_u64(1);
+                let __v_434: G = { let __values: [G; 3] = [__v_432, __v_433, __v_433]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_434]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
+                let __v_435: G = __r_arr[0];
+                let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_435]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
+                let __v_436: G = __r_arr[0];
+                let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_430, __v_436]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
                 let __v_437: G = __r_arr[0];
-                let __v_438: G = __r_arr[1];
-                let __v_439: G = __r_arr[2];
-                let __v_440: G = __r_arr[3];
-                let __v_441: G = __r_arr[4];
-                let __v_442: G = __r_arr[5];
-                let __v_443: G = __r_arr[6];
-                let __v_444: G = __r_arr[7];
-                let __v_445: G = __r_arr[8];
-                let __v_446: G = __r_arr[9];
-                let __v_447: G = __r_arr[10];
-                let __v_448: G = __r_arr[11];
-                let __v_449: G = __r_arr[12];
-                let __v_450: G = __r_arr[13];
-                let __v_451: G = __r_arr[14];
-                let __v_452: G = __r_arr[15];
-                let __v_453: G = __r_arr[16];
-                let __v_454: G = __r_arr[17];
-                let __v_455: G = G::from_u64(1);
-                let __v_456: G = G::from_u64(1);
-                let __v_457: G = { let __values: [G; 3] = [__v_455, __v_456, __v_456]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_445, __v_446, __v_447, __v_448, __v_449, __v_450, __v_451, __v_452, __v_457]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                let __v_458: G = __r_arr[0];
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_437, __v_438, __v_439, __v_440, __v_441, __v_442, __v_443, __v_444, __v_458]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                let __v_459: G = __r_arr[0];
-                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_453, __v_459]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                let __v_460: G = __r_arr[0];
-                let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_460, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-                let __v_461: G = __r_arr[0];
-                let __v_462: G = G::from_u64(1);
-                let __v_463: G = G::from_u64(1);
-                let __v_464: G = { let __values: [G; 3] = [__v_462, __v_463, __v_463]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_30, __v_464]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_438: G = G::from_u64(1);
+                let __v_439: G = G::from_u64(1);
+                let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_437, __v_440]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                let __v_441: G = __r_arr[0];
+                let __v_442: G = __r_arr[1];
+                let __v_443: G = __r_arr[2];
+                let __v_444: G = __r_arr[3];
+                let __v_445: G = __r_arr[4];
+                let __v_446: G = __r_arr[5];
+                let __v_447: G = __r_arr[6];
+                let __v_448: G = __r_arr[7];
+                let __v_449: G = __r_arr[8];
+                let __v_450: G = __r_arr[9];
+                let __v_451: G = __r_arr[10];
+                let __v_452: G = __r_arr[11];
+                let __v_453: G = __r_arr[12];
+                let __v_454: G = __r_arr[13];
+                let __v_455: G = __r_arr[14];
+                let __v_456: G = __r_arr[15];
+                let __v_457: G = __r_arr[16];
+                let __v_458: G = __r_arr[17];
+                let __v_459: G = G::from_u64(1);
+                let __v_460: G = G::from_u64(1);
+                let __v_461: G = { let __values: [G; 3] = [__v_459, __v_460, __v_460]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_449, __v_450, __v_451, __v_452, __v_453, __v_454, __v_455, __v_456, __v_461]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
+                let __v_462: G = __r_arr[0];
+                let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_441, __v_442, __v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_462]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
+                let __v_463: G = __r_arr[0];
+                let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_457, __v_463]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
+                let __v_464: G = __r_arr[0];
+                let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_464, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
                 let __v_465: G = __r_arr[0];
-                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_461, __v_465]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                let __v_466: G = __r_arr[0];
+                let __v_466: G = G::from_u64(1);
                 let __v_467: G = G::from_u64(1);
-                let __v_468: G = G::from_u64(1);
-                let __v_469: G = { let __values: [G; 3] = [__v_467, __v_468, __v_468]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_466, __v_469]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+                let __v_468: G = { let __values: [G; 3] = [__v_466, __v_467, __v_467]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_30, __v_468]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                let __v_469: G = __r_arr[0];
+                let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_465, __v_469]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
                 let __v_470: G = __r_arr[0];
-                let __v_471: G = __r_arr[1];
-                let __v_472: G = __r_arr[2];
-                let __v_473: G = __r_arr[3];
-                let __v_474: G = __r_arr[4];
-                let __v_475: G = __r_arr[5];
-                let __v_476: G = __r_arr[6];
-                let __v_477: G = __r_arr[7];
-                let __v_478: G = __r_arr[8];
-                let __v_479: G = __r_arr[9];
-                let __v_480: G = __r_arr[10];
-                let __v_481: G = __r_arr[11];
-                let __v_482: G = __r_arr[12];
-                let __v_483: G = __r_arr[13];
-                let __v_484: G = __r_arr[14];
-                let __v_485: G = __r_arr[15];
-                let __v_486: G = __r_arr[16];
-                let __v_487: G = __r_arr[17];
-                let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_486, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-                let __v_488: G = __r_arr[0];
-                let __v_489: G = G::from_u64(1);
-                let __v_490: G = G::from_u64(1);
-                let __v_491: G = { let __values: [G; 3] = [__v_489, __v_490, __v_490]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_488, __v_491]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+                let __v_471: G = G::from_u64(1);
+                let __v_472: G = G::from_u64(1);
+                let __v_473: G = { let __values: [G; 3] = [__v_471, __v_472, __v_472]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_470, __v_473]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                let __v_474: G = __r_arr[0];
+                let __v_475: G = __r_arr[1];
+                let __v_476: G = __r_arr[2];
+                let __v_477: G = __r_arr[3];
+                let __v_478: G = __r_arr[4];
+                let __v_479: G = __r_arr[5];
+                let __v_480: G = __r_arr[6];
+                let __v_481: G = __r_arr[7];
+                let __v_482: G = __r_arr[8];
+                let __v_483: G = __r_arr[9];
+                let __v_484: G = __r_arr[10];
+                let __v_485: G = __r_arr[11];
+                let __v_486: G = __r_arr[12];
+                let __v_487: G = __r_arr[13];
+                let __v_488: G = __r_arr[14];
+                let __v_489: G = __r_arr[15];
+                let __v_490: G = __r_arr[16];
+                let __v_491: G = __r_arr[17];
+                let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_490, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
                 let __v_492: G = __r_arr[0];
-                let __v_493: G = __r_arr[1];
-                let __v_494: G = __r_arr[2];
-                let __v_495: G = __r_arr[3];
-                let __v_496: G = __r_arr[4];
-                let __v_497: G = __r_arr[5];
-                let __v_498: G = __r_arr[6];
-                let __v_499: G = __r_arr[7];
-                let __v_500: G = __r_arr[8];
-                let __v_501: G = __r_arr[9];
-                let __v_502: G = __r_arr[10];
-                let __v_503: G = __r_arr[11];
-                let __v_504: G = __r_arr[12];
-                let __v_505: G = __r_arr[13];
-                let __v_506: G = __r_arr[14];
-                let __v_507: G = __r_arr[15];
-                let __v_508: G = __r_arr[16];
-                let __v_509: G = __r_arr[17];
-                let __v_510: G = G::from_u64(256);
-                let __v_511: G = (__v_510 * __v_411);
-                let __v_512: G = G::from_u64(65536);
-                let __v_513: G = (__v_512 * __v_412);
-                let __v_514: G = G::from_u64(16777216);
-                let __v_515: G = (__v_514 * __v_413);
-                let __v_516: G = G::from_u64(4294967296);
-                let __v_517: G = (__v_516 * __v_414);
-                let __v_518: G = G::from_u64(1099511627776);
-                let __v_519: G = (__v_518 * __v_415);
-                let __v_520: G = G::from_u64(281474976710656);
-                let __v_521: G = (__v_520 * __v_416);
-                let __v_522: G = G::from_u64(72057594037927936);
-                let __v_523: G = (__v_522 * __v_417);
-                let __v_524: G = (__v_521 + __v_523);
-                let __v_525: G = (__v_519 + __v_524);
-                let __v_526: G = (__v_517 + __v_525);
-                let __v_527: G = (__v_515 + __v_526);
-                let __v_528: G = (__v_513 + __v_527);
-                let __v_529: G = (__v_511 + __v_528);
-                let __v_530: G = (__v_410 + __v_529);
-                let __v_531: G = G::from_u64(256);
-                let __v_532: G = (__v_531 * __v_419);
-                let __v_533: G = G::from_u64(65536);
-                let __v_534: G = (__v_533 * __v_420);
-                let __v_535: G = G::from_u64(16777216);
-                let __v_536: G = (__v_535 * __v_421);
-                let __v_537: G = G::from_u64(4294967296);
-                let __v_538: G = (__v_537 * __v_422);
-                let __v_539: G = G::from_u64(1099511627776);
-                let __v_540: G = (__v_539 * __v_423);
-                let __v_541: G = G::from_u64(281474976710656);
-                let __v_542: G = (__v_541 * __v_424);
-                let __v_543: G = G::from_u64(72057594037927936);
-                let __v_544: G = (__v_543 * __v_425);
-                let __v_545: G = (__v_542 + __v_544);
-                let __v_546: G = (__v_540 + __v_545);
-                let __v_547: G = (__v_538 + __v_546);
-                let __v_548: G = (__v_536 + __v_547);
-                let __v_549: G = (__v_534 + __v_548);
-                let __v_550: G = (__v_532 + __v_549);
-                let __v_551: G = (__v_418 + __v_550);
-                let __v_552: G = G::from_u64(256);
-                let __v_553: G = (__v_552 * __v_438);
-                let __v_554: G = G::from_u64(65536);
-                let __v_555: G = (__v_554 * __v_439);
-                let __v_556: G = G::from_u64(16777216);
-                let __v_557: G = (__v_556 * __v_440);
-                let __v_558: G = G::from_u64(4294967296);
-                let __v_559: G = (__v_558 * __v_441);
-                let __v_560: G = G::from_u64(1099511627776);
-                let __v_561: G = (__v_560 * __v_442);
-                let __v_562: G = G::from_u64(281474976710656);
-                let __v_563: G = (__v_562 * __v_443);
-                let __v_564: G = G::from_u64(72057594037927936);
-                let __v_565: G = (__v_564 * __v_444);
-                let __v_566: G = (__v_563 + __v_565);
-                let __v_567: G = (__v_561 + __v_566);
-                let __v_568: G = (__v_559 + __v_567);
-                let __v_569: G = (__v_557 + __v_568);
-                let __v_570: G = (__v_555 + __v_569);
-                let __v_571: G = (__v_553 + __v_570);
-                let __v_572: G = (__v_437 + __v_571);
-                let __v_573: G = G::from_u64(256);
-                let __v_574: G = (__v_573 * __v_446);
-                let __v_575: G = G::from_u64(65536);
-                let __v_576: G = (__v_575 * __v_447);
-                let __v_577: G = G::from_u64(16777216);
-                let __v_578: G = (__v_577 * __v_448);
-                let __v_579: G = G::from_u64(4294967296);
-                let __v_580: G = (__v_579 * __v_449);
-                let __v_581: G = G::from_u64(1099511627776);
-                let __v_582: G = (__v_581 * __v_450);
-                let __v_583: G = G::from_u64(281474976710656);
-                let __v_584: G = (__v_583 * __v_451);
-                let __v_585: G = G::from_u64(72057594037927936);
-                let __v_586: G = (__v_585 * __v_452);
-                let __v_587: G = (__v_584 + __v_586);
-                let __v_588: G = (__v_582 + __v_587);
-                let __v_589: G = (__v_580 + __v_588);
-                let __v_590: G = (__v_578 + __v_589);
-                let __v_591: G = (__v_576 + __v_590);
-                let __v_592: G = (__v_574 + __v_591);
-                let __v_593: G = (__v_445 + __v_592);
-                let __v_594: G = G::from_u64(256);
-                let __v_595: G = (__v_594 * __v_471);
-                let __v_596: G = G::from_u64(65536);
-                let __v_597: G = (__v_596 * __v_472);
-                let __v_598: G = G::from_u64(16777216);
-                let __v_599: G = (__v_598 * __v_473);
-                let __v_600: G = G::from_u64(4294967296);
-                let __v_601: G = (__v_600 * __v_474);
-                let __v_602: G = G::from_u64(1099511627776);
-                let __v_603: G = (__v_602 * __v_475);
-                let __v_604: G = G::from_u64(281474976710656);
-                let __v_605: G = (__v_604 * __v_476);
-                let __v_606: G = G::from_u64(72057594037927936);
-                let __v_607: G = (__v_606 * __v_477);
-                let __v_608: G = (__v_605 + __v_607);
-                let __v_609: G = (__v_603 + __v_608);
-                let __v_610: G = (__v_601 + __v_609);
-                let __v_611: G = (__v_599 + __v_610);
-                let __v_612: G = (__v_597 + __v_611);
-                let __v_613: G = (__v_595 + __v_612);
-                let __v_614: G = (__v_470 + __v_613);
-                let __v_615: G = G::from_u64(256);
-                let __v_616: G = (__v_615 * __v_479);
-                let __v_617: G = G::from_u64(65536);
-                let __v_618: G = (__v_617 * __v_480);
-                let __v_619: G = G::from_u64(16777216);
-                let __v_620: G = (__v_619 * __v_481);
-                let __v_621: G = G::from_u64(4294967296);
-                let __v_622: G = (__v_621 * __v_482);
-                let __v_623: G = G::from_u64(1099511627776);
-                let __v_624: G = (__v_623 * __v_483);
-                let __v_625: G = G::from_u64(281474976710656);
-                let __v_626: G = (__v_625 * __v_484);
-                let __v_627: G = G::from_u64(72057594037927936);
-                let __v_628: G = (__v_627 * __v_485);
-                let __v_629: G = (__v_626 + __v_628);
-                let __v_630: G = (__v_624 + __v_629);
-                let __v_631: G = (__v_622 + __v_630);
-                let __v_632: G = (__v_620 + __v_631);
-                let __v_633: G = (__v_618 + __v_632);
-                let __v_634: G = (__v_616 + __v_633);
-                let __v_635: G = (__v_478 + __v_634);
-                let __v_636: G = G::from_u64(256);
-                let __v_637: G = (__v_636 * __v_493);
-                let __v_638: G = G::from_u64(65536);
-                let __v_639: G = (__v_638 * __v_494);
-                let __v_640: G = G::from_u64(16777216);
-                let __v_641: G = (__v_640 * __v_495);
-                let __v_642: G = G::from_u64(4294967296);
-                let __v_643: G = (__v_642 * __v_496);
-                let __v_644: G = G::from_u64(1099511627776);
-                let __v_645: G = (__v_644 * __v_497);
-                let __v_646: G = G::from_u64(281474976710656);
-                let __v_647: G = (__v_646 * __v_498);
-                let __v_648: G = G::from_u64(72057594037927936);
-                let __v_649: G = (__v_648 * __v_499);
-                let __v_650: G = (__v_647 + __v_649);
-                let __v_651: G = (__v_645 + __v_650);
-                let __v_652: G = (__v_643 + __v_651);
-                let __v_653: G = (__v_641 + __v_652);
-                let __v_654: G = (__v_639 + __v_653);
-                let __v_655: G = (__v_637 + __v_654);
-                let __v_656: G = (__v_492 + __v_655);
-                let __v_657: G = G::from_u64(256);
-                let __v_658: G = (__v_657 * __v_501);
-                let __v_659: G = G::from_u64(65536);
-                let __v_660: G = (__v_659 * __v_502);
-                let __v_661: G = G::from_u64(16777216);
-                let __v_662: G = (__v_661 * __v_503);
-                let __v_663: G = G::from_u64(4294967296);
-                let __v_664: G = (__v_663 * __v_504);
-                let __v_665: G = G::from_u64(1099511627776);
-                let __v_666: G = (__v_665 * __v_505);
-                let __v_667: G = G::from_u64(281474976710656);
-                let __v_668: G = (__v_667 * __v_506);
-                let __v_669: G = G::from_u64(72057594037927936);
-                let __v_670: G = (__v_669 * __v_507);
-                let __v_671: G = (__v_668 + __v_670);
-                let __v_672: G = (__v_666 + __v_671);
-                let __v_673: G = (__v_664 + __v_672);
-                let __v_674: G = (__v_662 + __v_673);
-                let __v_675: G = (__v_660 + __v_674);
-                let __v_676: G = (__v_658 + __v_675);
-                let __v_677: G = (__v_500 + __v_676);
-                let __v_678: G = G::from_u64(0);
-                let __v_679: G = G::from_u64(0);
-                let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_678, __v_679, __v_354, __v_530, __v_551, __v_572, __v_593]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
-                let __v_680: G = __r_arr[0];
-                let __v_681: G = __r_arr[1];
+                let __v_493: G = G::from_u64(1);
+                let __v_494: G = G::from_u64(1);
+                let __v_495: G = { let __values: [G; 3] = [__v_493, __v_494, __v_494]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_492, __v_495]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                let __v_496: G = __r_arr[0];
+                let __v_497: G = __r_arr[1];
+                let __v_498: G = __r_arr[2];
+                let __v_499: G = __r_arr[3];
+                let __v_500: G = __r_arr[4];
+                let __v_501: G = __r_arr[5];
+                let __v_502: G = __r_arr[6];
+                let __v_503: G = __r_arr[7];
+                let __v_504: G = __r_arr[8];
+                let __v_505: G = __r_arr[9];
+                let __v_506: G = __r_arr[10];
+                let __v_507: G = __r_arr[11];
+                let __v_508: G = __r_arr[12];
+                let __v_509: G = __r_arr[13];
+                let __v_510: G = __r_arr[14];
+                let __v_511: G = __r_arr[15];
+                let __v_512: G = __r_arr[16];
+                let __v_513: G = __r_arr[17];
+                let __v_514: G = G::from_u64(256);
+                let __v_515: G = (__v_514 * __v_415);
+                let __v_516: G = G::from_u64(65536);
+                let __v_517: G = (__v_516 * __v_416);
+                let __v_518: G = G::from_u64(16777216);
+                let __v_519: G = (__v_518 * __v_417);
+                let __v_520: G = G::from_u64(4294967296);
+                let __v_521: G = (__v_520 * __v_418);
+                let __v_522: G = G::from_u64(1099511627776);
+                let __v_523: G = (__v_522 * __v_419);
+                let __v_524: G = G::from_u64(281474976710656);
+                let __v_525: G = (__v_524 * __v_420);
+                let __v_526: G = G::from_u64(72057594037927936);
+                let __v_527: G = (__v_526 * __v_421);
+                let __v_528: G = (__v_525 + __v_527);
+                let __v_529: G = (__v_523 + __v_528);
+                let __v_530: G = (__v_521 + __v_529);
+                let __v_531: G = (__v_519 + __v_530);
+                let __v_532: G = (__v_517 + __v_531);
+                let __v_533: G = (__v_515 + __v_532);
+                let __v_534: G = (__v_414 + __v_533);
+                let __v_535: G = G::from_u64(256);
+                let __v_536: G = (__v_535 * __v_423);
+                let __v_537: G = G::from_u64(65536);
+                let __v_538: G = (__v_537 * __v_424);
+                let __v_539: G = G::from_u64(16777216);
+                let __v_540: G = (__v_539 * __v_425);
+                let __v_541: G = G::from_u64(4294967296);
+                let __v_542: G = (__v_541 * __v_426);
+                let __v_543: G = G::from_u64(1099511627776);
+                let __v_544: G = (__v_543 * __v_427);
+                let __v_545: G = G::from_u64(281474976710656);
+                let __v_546: G = (__v_545 * __v_428);
+                let __v_547: G = G::from_u64(72057594037927936);
+                let __v_548: G = (__v_547 * __v_429);
+                let __v_549: G = (__v_546 + __v_548);
+                let __v_550: G = (__v_544 + __v_549);
+                let __v_551: G = (__v_542 + __v_550);
+                let __v_552: G = (__v_540 + __v_551);
+                let __v_553: G = (__v_538 + __v_552);
+                let __v_554: G = (__v_536 + __v_553);
+                let __v_555: G = (__v_422 + __v_554);
+                let __v_556: G = G::from_u64(256);
+                let __v_557: G = (__v_556 * __v_442);
+                let __v_558: G = G::from_u64(65536);
+                let __v_559: G = (__v_558 * __v_443);
+                let __v_560: G = G::from_u64(16777216);
+                let __v_561: G = (__v_560 * __v_444);
+                let __v_562: G = G::from_u64(4294967296);
+                let __v_563: G = (__v_562 * __v_445);
+                let __v_564: G = G::from_u64(1099511627776);
+                let __v_565: G = (__v_564 * __v_446);
+                let __v_566: G = G::from_u64(281474976710656);
+                let __v_567: G = (__v_566 * __v_447);
+                let __v_568: G = G::from_u64(72057594037927936);
+                let __v_569: G = (__v_568 * __v_448);
+                let __v_570: G = (__v_567 + __v_569);
+                let __v_571: G = (__v_565 + __v_570);
+                let __v_572: G = (__v_563 + __v_571);
+                let __v_573: G = (__v_561 + __v_572);
+                let __v_574: G = (__v_559 + __v_573);
+                let __v_575: G = (__v_557 + __v_574);
+                let __v_576: G = (__v_441 + __v_575);
+                let __v_577: G = G::from_u64(256);
+                let __v_578: G = (__v_577 * __v_450);
+                let __v_579: G = G::from_u64(65536);
+                let __v_580: G = (__v_579 * __v_451);
+                let __v_581: G = G::from_u64(16777216);
+                let __v_582: G = (__v_581 * __v_452);
+                let __v_583: G = G::from_u64(4294967296);
+                let __v_584: G = (__v_583 * __v_453);
+                let __v_585: G = G::from_u64(1099511627776);
+                let __v_586: G = (__v_585 * __v_454);
+                let __v_587: G = G::from_u64(281474976710656);
+                let __v_588: G = (__v_587 * __v_455);
+                let __v_589: G = G::from_u64(72057594037927936);
+                let __v_590: G = (__v_589 * __v_456);
+                let __v_591: G = (__v_588 + __v_590);
+                let __v_592: G = (__v_586 + __v_591);
+                let __v_593: G = (__v_584 + __v_592);
+                let __v_594: G = (__v_582 + __v_593);
+                let __v_595: G = (__v_580 + __v_594);
+                let __v_596: G = (__v_578 + __v_595);
+                let __v_597: G = (__v_449 + __v_596);
+                let __v_598: G = G::from_u64(256);
+                let __v_599: G = (__v_598 * __v_475);
+                let __v_600: G = G::from_u64(65536);
+                let __v_601: G = (__v_600 * __v_476);
+                let __v_602: G = G::from_u64(16777216);
+                let __v_603: G = (__v_602 * __v_477);
+                let __v_604: G = G::from_u64(4294967296);
+                let __v_605: G = (__v_604 * __v_478);
+                let __v_606: G = G::from_u64(1099511627776);
+                let __v_607: G = (__v_606 * __v_479);
+                let __v_608: G = G::from_u64(281474976710656);
+                let __v_609: G = (__v_608 * __v_480);
+                let __v_610: G = G::from_u64(72057594037927936);
+                let __v_611: G = (__v_610 * __v_481);
+                let __v_612: G = (__v_609 + __v_611);
+                let __v_613: G = (__v_607 + __v_612);
+                let __v_614: G = (__v_605 + __v_613);
+                let __v_615: G = (__v_603 + __v_614);
+                let __v_616: G = (__v_601 + __v_615);
+                let __v_617: G = (__v_599 + __v_616);
+                let __v_618: G = (__v_474 + __v_617);
+                let __v_619: G = G::from_u64(256);
+                let __v_620: G = (__v_619 * __v_483);
+                let __v_621: G = G::from_u64(65536);
+                let __v_622: G = (__v_621 * __v_484);
+                let __v_623: G = G::from_u64(16777216);
+                let __v_624: G = (__v_623 * __v_485);
+                let __v_625: G = G::from_u64(4294967296);
+                let __v_626: G = (__v_625 * __v_486);
+                let __v_627: G = G::from_u64(1099511627776);
+                let __v_628: G = (__v_627 * __v_487);
+                let __v_629: G = G::from_u64(281474976710656);
+                let __v_630: G = (__v_629 * __v_488);
+                let __v_631: G = G::from_u64(72057594037927936);
+                let __v_632: G = (__v_631 * __v_489);
+                let __v_633: G = (__v_630 + __v_632);
+                let __v_634: G = (__v_628 + __v_633);
+                let __v_635: G = (__v_626 + __v_634);
+                let __v_636: G = (__v_624 + __v_635);
+                let __v_637: G = (__v_622 + __v_636);
+                let __v_638: G = (__v_620 + __v_637);
+                let __v_639: G = (__v_482 + __v_638);
+                let __v_640: G = G::from_u64(256);
+                let __v_641: G = (__v_640 * __v_497);
+                let __v_642: G = G::from_u64(65536);
+                let __v_643: G = (__v_642 * __v_498);
+                let __v_644: G = G::from_u64(16777216);
+                let __v_645: G = (__v_644 * __v_499);
+                let __v_646: G = G::from_u64(4294967296);
+                let __v_647: G = (__v_646 * __v_500);
+                let __v_648: G = G::from_u64(1099511627776);
+                let __v_649: G = (__v_648 * __v_501);
+                let __v_650: G = G::from_u64(281474976710656);
+                let __v_651: G = (__v_650 * __v_502);
+                let __v_652: G = G::from_u64(72057594037927936);
+                let __v_653: G = (__v_652 * __v_503);
+                let __v_654: G = (__v_651 + __v_653);
+                let __v_655: G = (__v_649 + __v_654);
+                let __v_656: G = (__v_647 + __v_655);
+                let __v_657: G = (__v_645 + __v_656);
+                let __v_658: G = (__v_643 + __v_657);
+                let __v_659: G = (__v_641 + __v_658);
+                let __v_660: G = (__v_496 + __v_659);
+                let __v_661: G = G::from_u64(256);
+                let __v_662: G = (__v_661 * __v_505);
+                let __v_663: G = G::from_u64(65536);
+                let __v_664: G = (__v_663 * __v_506);
+                let __v_665: G = G::from_u64(16777216);
+                let __v_666: G = (__v_665 * __v_507);
+                let __v_667: G = G::from_u64(4294967296);
+                let __v_668: G = (__v_667 * __v_508);
+                let __v_669: G = G::from_u64(1099511627776);
+                let __v_670: G = (__v_669 * __v_509);
+                let __v_671: G = G::from_u64(281474976710656);
+                let __v_672: G = (__v_671 * __v_510);
+                let __v_673: G = G::from_u64(72057594037927936);
+                let __v_674: G = (__v_673 * __v_511);
+                let __v_675: G = (__v_672 + __v_674);
+                let __v_676: G = (__v_670 + __v_675);
+                let __v_677: G = (__v_668 + __v_676);
+                let __v_678: G = (__v_666 + __v_677);
+                let __v_679: G = (__v_664 + __v_678);
+                let __v_680: G = (__v_662 + __v_679);
+                let __v_681: G = (__v_504 + __v_680);
                 let __v_682: G = G::from_u64(0);
-                let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_357, __v_358, __v_34, __v_30, __v_62, __v_64, __v_59, __v_60, __v_57, __v_682, __v_680, __v_681, __v_530, __v_551, __v_572, __v_593, __v_614, __v_635, __v_656, __v_677]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
-                let __v_683: G = __r_arr[0];
-                let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+                let __v_683: G = G::from_u64(0);
+                let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_682, __v_683, __v_358, __v_534, __v_555, __v_576, __v_597]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
                 let __v_684: G = __r_arr[0];
+                let __v_685: G = __r_arr[1];
+                let __v_686: G = G::from_u64(0);
+                let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_361, __v_362, __v_34, __v_30, __v_66, __v_68, __v_63, __v_64, __v_61, __v_686, __v_684, __v_685, __v_534, __v_555, __v_576, __v_597, __v_618, __v_639, __v_660, __v_681]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
+                let __v_687: G = __r_arr[0];
+                let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
+                let __v_688: G = __r_arr[0];
                 match __v_38.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                    let __v_685: G = __r_arr[0];
-                    let __v_686: G = G::from_u64(1);
-                    let __v_687: G = G::from_u64(1);
-                    let __v_688: G = { let __values: [G; 3] = [__v_686, __v_687, __v_687]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_59.as_canonical_u64() {
+                    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+                    let __v_689: G = __r_arr[0];
+                    let __v_690: G = G::from_u64(1);
+                    let __v_691: G = G::from_u64(1);
+                    let __v_692: G = { let __values: [G; 3] = [__v_690, __v_691, __v_691]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_63.as_canonical_u64() {
   0u64 => {
-    break '__mc_3 [__v_688];
+    break '__mc_3 [__v_692];
   },
   1u64 => {
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_60, __v_688]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-    let __v_689: G = __r_arr[0];
-    break '__mc_3 [__v_689];
+    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_64, __v_692]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_693: G = __r_arr[0];
+    break '__mc_3 [__v_693];
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_59.as_canonical_u64()));
+    return Err(ExecError::MatchNoCase(__v_63.as_canonical_u64()));
   },
 }
  };
-                    let __v_689: G = __mc_out___mc_3[0];
-                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_57, __v_689]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-                    let __v_690: G = __r_arr[0];
-                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_64, __v_690]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-                    let __v_691: G = __r_arr[0];
-                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_62, __v_691]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-                    let __v_692: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_508, __v_692]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                    let __v_693: G = __r_arr[0];
-                    let __v_694: G = G::from_u64(1);
-                    let __v_695: G = G::from_u64(1);
-                    let __v_696: G = { let __values: [G; 3] = [__v_694, __v_695, __v_695]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_693, __v_696]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+                    let __v_693: G = __mc_out___mc_3[0];
+                    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_61, __v_693]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_694: G = __r_arr[0];
+                    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_68, __v_694]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_695: G = __r_arr[0];
+                    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_66, __v_695]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { 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_696: G = __r_arr[0];
+                    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_512, __v_696]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
                     let __v_697: G = __r_arr[0];
-                    let __v_698: G = __r_arr[1];
-                    let __v_699: G = __r_arr[2];
-                    let __v_700: G = __r_arr[3];
-                    let __v_701: G = __r_arr[4];
-                    let __v_702: G = __r_arr[5];
-                    let __v_703: G = __r_arr[6];
-                    let __v_704: G = __r_arr[7];
-                    let __v_705: G = __r_arr[8];
-                    let __v_706: G = __r_arr[9];
-                    let __v_707: G = __r_arr[10];
-                    let __v_708: G = __r_arr[11];
-                    let __v_709: G = __r_arr[12];
-                    let __v_710: G = __r_arr[13];
-                    let __v_711: G = __r_arr[14];
-                    let __v_712: G = __r_arr[15];
-                    let __v_713: G = __r_arr[16];
-                    let __v_714: G = __r_arr[17];
-                    let __v_715: G = G::from_u64(256);
-                    let __v_716: G = (__v_715 * __v_698);
-                    let __v_717: G = G::from_u64(65536);
-                    let __v_718: G = (__v_717 * __v_699);
-                    let __v_719: G = G::from_u64(16777216);
-                    let __v_720: G = (__v_719 * __v_700);
-                    let __v_721: G = G::from_u64(4294967296);
-                    let __v_722: G = (__v_721 * __v_701);
-                    let __v_723: G = G::from_u64(1099511627776);
-                    let __v_724: G = (__v_723 * __v_702);
-                    let __v_725: G = G::from_u64(281474976710656);
-                    let __v_726: G = (__v_725 * __v_703);
-                    let __v_727: G = G::from_u64(72057594037927936);
-                    let __v_728: G = (__v_727 * __v_704);
-                    let __v_729: G = (__v_726 + __v_728);
-                    let __v_730: G = (__v_724 + __v_729);
-                    let __v_731: G = (__v_722 + __v_730);
-                    let __v_732: G = (__v_720 + __v_731);
-                    let __v_733: G = (__v_718 + __v_732);
-                    let __v_734: G = (__v_716 + __v_733);
-                    let __v_735: G = (__v_697 + __v_734);
-                    let __v_736: G = G::from_u64(256);
-                    let __v_737: G = (__v_736 * __v_706);
-                    let __v_738: G = G::from_u64(65536);
-                    let __v_739: G = (__v_738 * __v_707);
-                    let __v_740: G = G::from_u64(16777216);
-                    let __v_741: G = (__v_740 * __v_708);
-                    let __v_742: G = G::from_u64(4294967296);
-                    let __v_743: G = (__v_742 * __v_709);
-                    let __v_744: G = G::from_u64(1099511627776);
-                    let __v_745: G = (__v_744 * __v_710);
-                    let __v_746: G = G::from_u64(281474976710656);
-                    let __v_747: G = (__v_746 * __v_711);
-                    let __v_748: G = G::from_u64(72057594037927936);
-                    let __v_749: G = (__v_748 * __v_712);
-                    let __v_750: G = (__v_747 + __v_749);
-                    let __v_751: G = (__v_745 + __v_750);
-                    let __v_752: G = (__v_743 + __v_751);
-                    let __v_753: G = (__v_741 + __v_752);
-                    let __v_754: G = (__v_739 + __v_753);
-                    let __v_755: G = (__v_737 + __v_754);
-                    let __v_756: G = (__v_705 + __v_755);
-                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_713, __v_38, __v_40, __v_205]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
-                    let __v_757: G = __r_arr[0];
-                    let __v_758: G = __r_arr[1];
-                    let __v_759: G = G::from_u64(1);
-                    let __v_760: G = G::from_u64(1);
-                    let __v_761: G = { let __values: [G; 3] = [__v_759, __v_760, __v_760]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_46, __v_761]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { 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_762: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_758, __v_762]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                    let __v_763: G = __r_arr[0];
-                    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_763, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
-                    let __v_764: G = __r_arr[0];
-                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_764, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
-                    let __v_765: G = __r_arr[0];
-                    let __v_766: G = __r_arr[1];
-                    let __v_767: G = (__v_685 + __v_155);
-                    let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
+                    let __v_698: G = G::from_u64(1);
+                    let __v_699: G = G::from_u64(1);
+                    let __v_700: G = { let __values: [G; 3] = [__v_698, __v_699, __v_699]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_697, __v_700]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                    let __v_701: G = __r_arr[0];
+                    let __v_702: G = __r_arr[1];
+                    let __v_703: G = __r_arr[2];
+                    let __v_704: G = __r_arr[3];
+                    let __v_705: G = __r_arr[4];
+                    let __v_706: G = __r_arr[5];
+                    let __v_707: G = __r_arr[6];
+                    let __v_708: G = __r_arr[7];
+                    let __v_709: G = __r_arr[8];
+                    let __v_710: G = __r_arr[9];
+                    let __v_711: G = __r_arr[10];
+                    let __v_712: G = __r_arr[11];
+                    let __v_713: G = __r_arr[12];
+                    let __v_714: G = __r_arr[13];
+                    let __v_715: G = __r_arr[14];
+                    let __v_716: G = __r_arr[15];
+                    let __v_717: G = __r_arr[16];
+                    let __v_718: G = __r_arr[17];
+                    let __v_719: G = G::from_u64(256);
+                    let __v_720: G = (__v_719 * __v_702);
+                    let __v_721: G = G::from_u64(65536);
+                    let __v_722: G = (__v_721 * __v_703);
+                    let __v_723: G = G::from_u64(16777216);
+                    let __v_724: G = (__v_723 * __v_704);
+                    let __v_725: G = G::from_u64(4294967296);
+                    let __v_726: G = (__v_725 * __v_705);
+                    let __v_727: G = G::from_u64(1099511627776);
+                    let __v_728: G = (__v_727 * __v_706);
+                    let __v_729: G = G::from_u64(281474976710656);
+                    let __v_730: G = (__v_729 * __v_707);
+                    let __v_731: G = G::from_u64(72057594037927936);
+                    let __v_732: G = (__v_731 * __v_708);
+                    let __v_733: G = (__v_730 + __v_732);
+                    let __v_734: G = (__v_728 + __v_733);
+                    let __v_735: G = (__v_726 + __v_734);
+                    let __v_736: G = (__v_724 + __v_735);
+                    let __v_737: G = (__v_722 + __v_736);
+                    let __v_738: G = (__v_720 + __v_737);
+                    let __v_739: G = (__v_701 + __v_738);
+                    let __v_740: G = G::from_u64(256);
+                    let __v_741: G = (__v_740 * __v_710);
+                    let __v_742: G = G::from_u64(65536);
+                    let __v_743: G = (__v_742 * __v_711);
+                    let __v_744: G = G::from_u64(16777216);
+                    let __v_745: G = (__v_744 * __v_712);
+                    let __v_746: G = G::from_u64(4294967296);
+                    let __v_747: G = (__v_746 * __v_713);
+                    let __v_748: G = G::from_u64(1099511627776);
+                    let __v_749: G = (__v_748 * __v_714);
+                    let __v_750: G = G::from_u64(281474976710656);
+                    let __v_751: G = (__v_750 * __v_715);
+                    let __v_752: G = G::from_u64(72057594037927936);
+                    let __v_753: G = (__v_752 * __v_716);
+                    let __v_754: G = (__v_751 + __v_753);
+                    let __v_755: G = (__v_749 + __v_754);
+                    let __v_756: G = (__v_747 + __v_755);
+                    let __v_757: G = (__v_745 + __v_756);
+                    let __v_758: G = (__v_743 + __v_757);
+                    let __v_759: G = (__v_741 + __v_758);
+                    let __v_760: G = (__v_709 + __v_759);
+                    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_717, __v_38, __v_40, __v_209]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } };
+                    let __v_761: G = __r_arr[0];
+                    let __v_762: G = __r_arr[1];
+                    let __v_763: G = G::from_u64(1);
+                    let __v_764: G = G::from_u64(1);
+                    let __v_765: G = { let __values: [G; 3] = [__v_763, __v_764, __v_764]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_50, __v_765]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                    let __v_766: G = __r_arr[0];
+                    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_762, __v_766]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
+                    let __v_767: G = __r_arr[0];
+                    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_767, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
                     let __v_768: G = __r_arr[0];
-                    let __v_769: G = G::from_u64(1);
-                    if (__v_768 != __v_769) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_768.as_canonical_u64(), rhs: __v_769.as_canonical_u64(), msg: None });
+                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_768, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_219]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { 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_769: G = __r_arr[0];
+                    let __v_770: G = __r_arr[1];
+                    let __v_771: G = (__v_689 + __v_159);
+                    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_769, __v_770, __v_199, __v_771]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+                    let __v_772: G = __r_arr[0];
+                    let __v_773: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_44, __v_48, __v_773, __v_199]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
+                    let __v_774: G = __r_arr[0];
+                    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_769, __v_770, __v_774, __v_739, __v_760, __v_66, __v_68, __v_61, __v_63, __v_64, __v_24, __v_26, __v_28, __v_363, __v_362, __v_34, __v_660, __v_681, __v_688, __v_159, __v_771, __v_761, __v_38, __v_50, __v_689]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+                    let __v_775: G = __r_arr[0];
+                    let __v_776: G = G::from_u64(0);
+                    if (__v_169 != __v_776) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_776.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                    let __v_770: G = __r_arr[0];
-                    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_252]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
-                    let __v_771: G = __r_arr[0];
-                    let __v_772: G = (__v_770 - __v_771);
-                    let __v_773: G = G::from_bool((__v_772 == G::ZERO));
-                    let __v_774: G = G::from_u64(1);
-                    if (__v_773 != __v_774) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_773.as_canonical_u64(), rhs: __v_774.as_canonical_u64(), msg: None });
+                    let __v_777: G = G::from_u64(0);
+                    if (__v_179 != __v_777) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_777.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
-                    let __v_775: G = __r_arr[0];
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-                    let __v_776: G = __r_arr[0];
-                    let __v_777: G = (__v_775 - __v_776);
-                    let __v_778: G = G::from_bool((__v_777 == G::ZERO));
-                    let __v_779: G = G::from_u64(1);
-                    if (__v_778 != __v_779) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_778.as_canonical_u64(), rhs: __v_779.as_canonical_u64(), msg: None });
+                    let __v_778: G = G::from_u64(1);
+                    if (__v_189 != __v_778) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_778.as_canonical_u64(), msg: None });
+                    }
+                    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
+                    let __v_779: G = __r_arr[0];
+                    let __v_780: G = G::from_u64(1);
+                    if (__v_779 != __v_780) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_779.as_canonical_u64(), rhs: __v_780.as_canonical_u64(), msg: None });
+                    }
+                    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+                    let __v_781: G = __r_arr[0];
+                    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_256]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
+                    let __v_782: G = __r_arr[0];
+                    let __v_783: G = (__v_781 - __v_782);
+                    let __v_784: G = G::from_bool((__v_783 == G::ZERO));
+                    let __v_785: G = G::from_u64(1);
+                    if (__v_784 != __v_785) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_784.as_canonical_u64(), rhs: __v_785.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
-                    let __v_780: G = __r_arr[0];
-                    let __v_781: G = (__v_780 - __v_685);
-                    let __v_782: G = G::from_bool((__v_781 == G::ZERO));
-                    let __v_783: G = G::from_u64(1);
-                    if (__v_782 != __v_783) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_782.as_canonical_u64(), rhs: __v_783.as_canonical_u64(), msg: None });
+                    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
+                    let __v_786: G = __r_arr[0];
+                    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+                    let __v_787: G = __r_arr[0];
+                    let __v_788: G = (__v_786 - __v_787);
+                    let __v_789: G = G::from_bool((__v_788 == G::ZERO));
+                    let __v_790: G = G::from_u64(1);
+                    if (__v_789 != __v_790) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_789.as_canonical_u64(), rhs: __v_790.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-                    let __v_784: G = __r_arr[0];
-                    let __v_785: G = (__v_784 - __v_195);
-                    let __v_786: G = G::from_bool((__v_785 == G::ZERO));
-                    let __v_787: G = G::from_u64(1);
-                    if (__v_786 != __v_787) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_786.as_canonical_u64(), rhs: __v_787.as_canonical_u64(), msg: None });
+                    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+                    let __v_791: G = __r_arr[0];
+                    let __v_792: G = (__v_791 - __v_689);
+                    let __v_793: G = G::from_bool((__v_792 == G::ZERO));
+                    let __v_794: G = G::from_u64(1);
+                    if (__v_793 != __v_794) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_793.as_canonical_u64(), rhs: __v_794.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-                    let __v_788: G = __r_arr[0];
-                    let __v_789: G = G::from_u64(1);
-                    if (__v_788 != __v_789) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_788.as_canonical_u64(), rhs: __v_789.as_canonical_u64(), msg: None });
+                    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+                    let __v_795: G = __r_arr[0];
+                    let __v_796: G = G::from_u64(3);
+                    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+                    let __v_797: G = __r_arr[0];
+                    let __v_798: G = (__v_796 + __v_797);
+                    if (__v_795 != __v_798) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_795.as_canonical_u64(), rhs: __v_798.as_canonical_u64(), msg: None });
                     }
-                    let __v_790: G = G::from_u64(33);
-                    let __v_791: G = { let __a_val = __v_767.as_canonical_u64(); let __b_val = __v_790.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                    let __v_792: G = G::from_u64(1);
-                    if (__v_791 != __v_792) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_791.as_canonical_u64(), rhs: __v_792.as_canonical_u64(), msg: None });
+                    let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
+                    let __v_799: G = __r_arr[0];
+                    let __v_800: G = (__v_799 - __v_689);
+                    let __v_801: G = G::from_bool((__v_800 == G::ZERO));
+                    let __v_802: G = G::from_u64(1);
+                    if (__v_801 != __v_802) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_801.as_canonical_u64(), rhs: __v_802.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_765, __v_766, __v_44, __v_735, __v_756, __v_62, __v_64, __v_57, __v_59, __v_60, __v_24, __v_26, __v_28, __v_359, __v_358, __v_34, __v_656, __v_677, __v_684, __v_155, __v_767, __v_757, __v_38, __v_46, __v_685]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { 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_793: G = __r_arr[0];
-                    break '__mc_1 [__v_793];
+                    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+                    let __v_803: G = __r_arr[0];
+                    let __v_804: G = G::from_u64(1);
+                    if (__v_803 != __v_804) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_803.as_canonical_u64(), rhs: __v_804.as_canonical_u64(), msg: None });
+                    }
+                    let __v_805: G = G::from_u64(33);
+                    let __v_806: G = { let __a_val = __v_771.as_canonical_u64(); let __b_val = __v_805.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                    let __v_807: G = G::from_u64(1);
+                    if (__v_806 != __v_807) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_806.as_canonical_u64(), rhs: __v_807.as_canonical_u64(), msg: None });
+                    }
+                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_44, __v_772, __v_24, __v_26, __v_28, __v_363, __v_63, __v_64, __v_362, __v_34, __v_688, __v_159, __v_771]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+                    let __v_808: G = __r_arr[0];
+                    let __v_809: G = G::from_u64(1);
+                    if (__v_808 != __v_809) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_808.as_canonical_u64(), rhs: __v_809.as_canonical_u64(), msg: None });
+                    }
+                    let __v_810: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_48, __v_38, __v_775, __v_772, __v_810, __v_771]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
+                    let __v_811: G = __r_arr[0];
+                    break '__mc_1 [__v_811];
                   },
                 }
               },
@@ -19184,260 +20239,260 @@ fn aiur_fn_191(
   },
 }
  };
-    let __v_357: G = __mc_out___mc_1[0];
-    let __v_358: G = (__v_18 + __v_19);
-    if (__v_65 != __v_358) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_358.as_canonical_u64(), msg: None });
+    let __v_361: G = __mc_out___mc_1[0];
+    let __v_362: G = (__v_18 + __v_19);
+    if (__v_69 != __v_362) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_362.as_canonical_u64(), msg: None });
     }
-    let __v_359: G = G::from_u64(256);
-    let __v_360: G = (__v_359 * __v_124);
-    let __v_361: G = G::from_u64(65536);
-    let __v_362: G = (__v_361 * __v_125);
-    let __v_363: G = G::from_u64(16777216);
-    let __v_364: G = (__v_363 * __v_126);
-    let __v_365: G = (__v_362 + __v_364);
-    let __v_366: G = (__v_360 + __v_365);
-    let __v_367: G = (__v_123 + __v_366);
-    let __v_368: G = G::from_u64(256);
-    let __v_369: G = (__v_368 * __v_128);
-    let __v_370: G = G::from_u64(65536);
-    let __v_371: G = (__v_370 * __v_129);
-    let __v_372: G = G::from_u64(16777216);
-    let __v_373: G = (__v_372 * __v_130);
-    let __v_374: G = (__v_371 + __v_373);
-    let __v_375: G = (__v_369 + __v_374);
-    let __v_376: G = (__v_127 + __v_375);
-    let __v_377: G = G::from_u64(256);
-    let __v_378: G = (__v_377 * __v_132);
-    let __v_379: G = G::from_u64(65536);
-    let __v_380: G = (__v_379 * __v_133);
-    let __v_381: G = G::from_u64(16777216);
-    let __v_382: G = (__v_381 * __v_134);
-    let __v_383: G = (__v_380 + __v_382);
-    let __v_384: G = (__v_378 + __v_383);
-    let __v_385: G = (__v_131 + __v_384);
-    let __v_386: G = G::from_u64(256);
-    let __v_387: G = (__v_386 * __v_136);
-    let __v_388: G = G::from_u64(65536);
-    let __v_389: G = (__v_388 * __v_137);
-    let __v_390: G = G::from_u64(16777216);
-    let __v_391: G = (__v_390 * __v_138);
-    let __v_392: G = (__v_389 + __v_391);
-    let __v_393: G = (__v_387 + __v_392);
-    let __v_394: G = (__v_135 + __v_393);
-    let __v_395: G = G::from_u64(256);
-    let __v_396: G = (__v_395 * __v_140);
-    let __v_397: G = G::from_u64(65536);
-    let __v_398: G = (__v_397 * __v_141);
-    let __v_399: G = G::from_u64(16777216);
-    let __v_400: G = (__v_399 * __v_142);
-    let __v_401: G = (__v_398 + __v_400);
-    let __v_402: G = (__v_396 + __v_401);
-    let __v_403: G = (__v_139 + __v_402);
-    let __v_404: G = G::from_u64(256);
-    let __v_405: G = (__v_404 * __v_144);
-    let __v_406: G = G::from_u64(65536);
-    let __v_407: G = (__v_406 * __v_145);
-    let __v_408: G = G::from_u64(16777216);
-    let __v_409: G = (__v_408 * __v_146);
-    let __v_410: G = (__v_407 + __v_409);
-    let __v_411: G = (__v_405 + __v_410);
-    let __v_412: G = (__v_143 + __v_411);
-    let __v_413: G = G::from_u64(256);
-    let __v_414: G = (__v_413 * __v_148);
-    let __v_415: G = G::from_u64(65536);
-    let __v_416: G = (__v_415 * __v_149);
-    let __v_417: G = G::from_u64(16777216);
-    let __v_418: G = (__v_417 * __v_150);
-    let __v_419: G = (__v_416 + __v_418);
-    let __v_420: G = (__v_414 + __v_419);
-    let __v_421: G = (__v_147 + __v_420);
-    let __v_422: G = G::from_u64(256);
-    let __v_423: G = (__v_422 * __v_152);
-    let __v_424: G = G::from_u64(65536);
-    let __v_425: G = (__v_424 * __v_153);
-    let __v_426: G = G::from_u64(16777216);
-    let __v_427: G = (__v_426 * __v_154);
-    let __v_428: G = (__v_425 + __v_427);
-    let __v_429: G = (__v_423 + __v_428);
-    let __v_430: G = (__v_151 + __v_429);
-    if (__v_367 != __v_0) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_367.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None });
+    let __v_363: G = G::from_u64(256);
+    let __v_364: G = (__v_363 * __v_128);
+    let __v_365: G = G::from_u64(65536);
+    let __v_366: G = (__v_365 * __v_129);
+    let __v_367: G = G::from_u64(16777216);
+    let __v_368: G = (__v_367 * __v_130);
+    let __v_369: G = (__v_366 + __v_368);
+    let __v_370: G = (__v_364 + __v_369);
+    let __v_371: G = (__v_127 + __v_370);
+    let __v_372: G = G::from_u64(256);
+    let __v_373: G = (__v_372 * __v_132);
+    let __v_374: G = G::from_u64(65536);
+    let __v_375: G = (__v_374 * __v_133);
+    let __v_376: G = G::from_u64(16777216);
+    let __v_377: G = (__v_376 * __v_134);
+    let __v_378: G = (__v_375 + __v_377);
+    let __v_379: G = (__v_373 + __v_378);
+    let __v_380: G = (__v_131 + __v_379);
+    let __v_381: G = G::from_u64(256);
+    let __v_382: G = (__v_381 * __v_136);
+    let __v_383: G = G::from_u64(65536);
+    let __v_384: G = (__v_383 * __v_137);
+    let __v_385: G = G::from_u64(16777216);
+    let __v_386: G = (__v_385 * __v_138);
+    let __v_387: G = (__v_384 + __v_386);
+    let __v_388: G = (__v_382 + __v_387);
+    let __v_389: G = (__v_135 + __v_388);
+    let __v_390: G = G::from_u64(256);
+    let __v_391: G = (__v_390 * __v_140);
+    let __v_392: G = G::from_u64(65536);
+    let __v_393: G = (__v_392 * __v_141);
+    let __v_394: G = G::from_u64(16777216);
+    let __v_395: G = (__v_394 * __v_142);
+    let __v_396: G = (__v_393 + __v_395);
+    let __v_397: G = (__v_391 + __v_396);
+    let __v_398: G = (__v_139 + __v_397);
+    let __v_399: G = G::from_u64(256);
+    let __v_400: G = (__v_399 * __v_144);
+    let __v_401: G = G::from_u64(65536);
+    let __v_402: G = (__v_401 * __v_145);
+    let __v_403: G = G::from_u64(16777216);
+    let __v_404: G = (__v_403 * __v_146);
+    let __v_405: G = (__v_402 + __v_404);
+    let __v_406: G = (__v_400 + __v_405);
+    let __v_407: G = (__v_143 + __v_406);
+    let __v_408: G = G::from_u64(256);
+    let __v_409: G = (__v_408 * __v_148);
+    let __v_410: G = G::from_u64(65536);
+    let __v_411: G = (__v_410 * __v_149);
+    let __v_412: G = G::from_u64(16777216);
+    let __v_413: G = (__v_412 * __v_150);
+    let __v_414: G = (__v_411 + __v_413);
+    let __v_415: G = (__v_409 + __v_414);
+    let __v_416: G = (__v_147 + __v_415);
+    let __v_417: G = G::from_u64(256);
+    let __v_418: G = (__v_417 * __v_152);
+    let __v_419: G = G::from_u64(65536);
+    let __v_420: G = (__v_419 * __v_153);
+    let __v_421: G = G::from_u64(16777216);
+    let __v_422: G = (__v_421 * __v_154);
+    let __v_423: G = (__v_420 + __v_422);
+    let __v_424: G = (__v_418 + __v_423);
+    let __v_425: G = (__v_151 + __v_424);
+    let __v_426: G = G::from_u64(256);
+    let __v_427: G = (__v_426 * __v_156);
+    let __v_428: G = G::from_u64(65536);
+    let __v_429: G = (__v_428 * __v_157);
+    let __v_430: G = G::from_u64(16777216);
+    let __v_431: G = (__v_430 * __v_158);
+    let __v_432: G = (__v_429 + __v_431);
+    let __v_433: G = (__v_427 + __v_432);
+    let __v_434: G = (__v_155 + __v_433);
+    if (__v_371 != __v_0) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_371.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None });
     }
-    if (__v_376 != __v_1) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_376.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None });
+    if (__v_380 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_380.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None });
     }
-    if (__v_385 != __v_2) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_385.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None });
+    if (__v_389 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_389.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None });
     }
-    if (__v_394 != __v_3) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_394.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
+    if (__v_398 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_398.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
     }
-    if (__v_403 != __v_4) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_403.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None });
+    if (__v_407 != __v_4) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_407.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None });
     }
-    if (__v_412 != __v_5) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_412.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None });
+    if (__v_416 != __v_5) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_416.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None });
     }
-    if (__v_421 != __v_6) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_421.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None });
+    if (__v_425 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_425.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None });
     }
-    if (__v_430 != __v_7) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_430.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None });
+    if (__v_434 != __v_7) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_434.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None });
     }
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_259.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_431: G = __loaded[0];
-    let __v_432: G = __loaded[1];
-    let __v_433: G = __loaded[2];
-    let __v_434: G = G::from_u64(1);
-    let __v_435: G = G::from_u64(1);
-    if (__v_431 != __v_434) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_431.as_canonical_u64(), rhs: __v_434.as_canonical_u64(), msg: None });
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_263.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_435: G = __loaded[0];
+    let __v_436: G = __loaded[1];
+    let __v_437: G = __loaded[2];
+    let __v_438: G = G::from_u64(1);
+    let __v_439: G = G::from_u64(1);
+    if (__v_435 != __v_438) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_435.as_canonical_u64(), rhs: __v_438.as_canonical_u64(), msg: None });
     }
-    if (__v_432 != __v_435) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_432.as_canonical_u64(), rhs: __v_435.as_canonical_u64(), msg: None });
+    if (__v_436 != __v_439) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_436.as_canonical_u64(), rhs: __v_439.as_canonical_u64(), msg: None });
     }
-    if (__v_433 != __v_435) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_433.as_canonical_u64(), rhs: __v_435.as_canonical_u64(), msg: None });
+    if (__v_437 != __v_439) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_437.as_canonical_u64(), rhs: __v_439.as_canonical_u64(), msg: None });
     }
-    let __v_436: G = G::from_u64(256);
-    let __v_437: G = (__v_436 * __v_321);
-    let __v_438: G = G::from_u64(65536);
-    let __v_439: G = (__v_438 * __v_322);
-    let __v_440: G = G::from_u64(16777216);
-    let __v_441: G = (__v_440 * __v_323);
-    let __v_442: G = (__v_439 + __v_441);
-    let __v_443: G = (__v_437 + __v_442);
-    let __v_444: G = (__v_320 + __v_443);
-    let __v_445: G = G::from_u64(256);
-    let __v_446: G = (__v_445 * __v_325);
-    let __v_447: G = G::from_u64(65536);
-    let __v_448: G = (__v_447 * __v_326);
-    let __v_449: G = G::from_u64(16777216);
-    let __v_450: G = (__v_449 * __v_327);
-    let __v_451: G = (__v_448 + __v_450);
-    let __v_452: G = (__v_446 + __v_451);
-    let __v_453: G = (__v_324 + __v_452);
-    let __v_454: G = G::from_u64(256);
-    let __v_455: G = (__v_454 * __v_329);
-    let __v_456: G = G::from_u64(65536);
-    let __v_457: G = (__v_456 * __v_330);
-    let __v_458: G = G::from_u64(16777216);
-    let __v_459: G = (__v_458 * __v_331);
-    let __v_460: G = (__v_457 + __v_459);
-    let __v_461: G = (__v_455 + __v_460);
-    let __v_462: G = (__v_328 + __v_461);
-    let __v_463: G = G::from_u64(256);
-    let __v_464: G = (__v_463 * __v_333);
-    let __v_465: G = G::from_u64(65536);
-    let __v_466: G = (__v_465 * __v_334);
-    let __v_467: G = G::from_u64(16777216);
-    let __v_468: G = (__v_467 * __v_335);
-    let __v_469: G = (__v_466 + __v_468);
-    let __v_470: G = (__v_464 + __v_469);
-    let __v_471: G = (__v_332 + __v_470);
-    let __v_472: G = G::from_u64(256);
-    let __v_473: G = (__v_472 * __v_337);
-    let __v_474: G = G::from_u64(65536);
-    let __v_475: G = (__v_474 * __v_338);
-    let __v_476: G = G::from_u64(16777216);
-    let __v_477: G = (__v_476 * __v_339);
-    let __v_478: G = (__v_475 + __v_477);
-    let __v_479: G = (__v_473 + __v_478);
-    let __v_480: G = (__v_336 + __v_479);
-    let __v_481: G = G::from_u64(256);
-    let __v_482: G = (__v_481 * __v_341);
-    let __v_483: G = G::from_u64(65536);
-    let __v_484: G = (__v_483 * __v_342);
-    let __v_485: G = G::from_u64(16777216);
-    let __v_486: G = (__v_485 * __v_343);
-    let __v_487: G = (__v_484 + __v_486);
-    let __v_488: G = (__v_482 + __v_487);
-    let __v_489: G = (__v_340 + __v_488);
-    let __v_490: G = G::from_u64(256);
-    let __v_491: G = (__v_490 * __v_345);
-    let __v_492: G = G::from_u64(65536);
-    let __v_493: G = (__v_492 * __v_346);
-    let __v_494: G = G::from_u64(16777216);
-    let __v_495: G = (__v_494 * __v_347);
-    let __v_496: G = (__v_493 + __v_495);
-    let __v_497: G = (__v_491 + __v_496);
-    let __v_498: G = (__v_344 + __v_497);
-    let __v_499: G = G::from_u64(256);
-    let __v_500: G = (__v_499 * __v_349);
-    let __v_501: G = G::from_u64(65536);
-    let __v_502: G = (__v_501 * __v_350);
-    let __v_503: G = G::from_u64(16777216);
-    let __v_504: G = (__v_503 * __v_351);
-    let __v_505: G = (__v_502 + __v_504);
-    let __v_506: G = (__v_500 + __v_505);
-    let __v_507: G = (__v_348 + __v_506);
-    if (__v_444 != __v_8) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_444.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
+    let __v_440: G = G::from_u64(256);
+    let __v_441: G = (__v_440 * __v_325);
+    let __v_442: G = G::from_u64(65536);
+    let __v_443: G = (__v_442 * __v_326);
+    let __v_444: G = G::from_u64(16777216);
+    let __v_445: G = (__v_444 * __v_327);
+    let __v_446: G = (__v_443 + __v_445);
+    let __v_447: G = (__v_441 + __v_446);
+    let __v_448: G = (__v_324 + __v_447);
+    let __v_449: G = G::from_u64(256);
+    let __v_450: G = (__v_449 * __v_329);
+    let __v_451: G = G::from_u64(65536);
+    let __v_452: G = (__v_451 * __v_330);
+    let __v_453: G = G::from_u64(16777216);
+    let __v_454: G = (__v_453 * __v_331);
+    let __v_455: G = (__v_452 + __v_454);
+    let __v_456: G = (__v_450 + __v_455);
+    let __v_457: G = (__v_328 + __v_456);
+    let __v_458: G = G::from_u64(256);
+    let __v_459: G = (__v_458 * __v_333);
+    let __v_460: G = G::from_u64(65536);
+    let __v_461: G = (__v_460 * __v_334);
+    let __v_462: G = G::from_u64(16777216);
+    let __v_463: G = (__v_462 * __v_335);
+    let __v_464: G = (__v_461 + __v_463);
+    let __v_465: G = (__v_459 + __v_464);
+    let __v_466: G = (__v_332 + __v_465);
+    let __v_467: G = G::from_u64(256);
+    let __v_468: G = (__v_467 * __v_337);
+    let __v_469: G = G::from_u64(65536);
+    let __v_470: G = (__v_469 * __v_338);
+    let __v_471: G = G::from_u64(16777216);
+    let __v_472: G = (__v_471 * __v_339);
+    let __v_473: G = (__v_470 + __v_472);
+    let __v_474: G = (__v_468 + __v_473);
+    let __v_475: G = (__v_336 + __v_474);
+    let __v_476: G = G::from_u64(256);
+    let __v_477: G = (__v_476 * __v_341);
+    let __v_478: G = G::from_u64(65536);
+    let __v_479: G = (__v_478 * __v_342);
+    let __v_480: G = G::from_u64(16777216);
+    let __v_481: G = (__v_480 * __v_343);
+    let __v_482: G = (__v_479 + __v_481);
+    let __v_483: G = (__v_477 + __v_482);
+    let __v_484: G = (__v_340 + __v_483);
+    let __v_485: G = G::from_u64(256);
+    let __v_486: G = (__v_485 * __v_345);
+    let __v_487: G = G::from_u64(65536);
+    let __v_488: G = (__v_487 * __v_346);
+    let __v_489: G = G::from_u64(16777216);
+    let __v_490: G = (__v_489 * __v_347);
+    let __v_491: G = (__v_488 + __v_490);
+    let __v_492: G = (__v_486 + __v_491);
+    let __v_493: G = (__v_344 + __v_492);
+    let __v_494: G = G::from_u64(256);
+    let __v_495: G = (__v_494 * __v_349);
+    let __v_496: G = G::from_u64(65536);
+    let __v_497: G = (__v_496 * __v_350);
+    let __v_498: G = G::from_u64(16777216);
+    let __v_499: G = (__v_498 * __v_351);
+    let __v_500: G = (__v_497 + __v_499);
+    let __v_501: G = (__v_495 + __v_500);
+    let __v_502: G = (__v_348 + __v_501);
+    let __v_503: G = G::from_u64(256);
+    let __v_504: G = (__v_503 * __v_353);
+    let __v_505: G = G::from_u64(65536);
+    let __v_506: G = (__v_505 * __v_354);
+    let __v_507: G = G::from_u64(16777216);
+    let __v_508: G = (__v_507 * __v_355);
+    let __v_509: G = (__v_506 + __v_508);
+    let __v_510: G = (__v_504 + __v_509);
+    let __v_511: G = (__v_352 + __v_510);
+    if (__v_448 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_448.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
     }
-    if (__v_453 != __v_9) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_453.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None });
+    if (__v_457 != __v_9) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_457.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None });
     }
-    if (__v_462 != __v_10) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_462.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None });
+    if (__v_466 != __v_10) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_466.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None });
     }
-    if (__v_471 != __v_11) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_471.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None });
+    if (__v_475 != __v_11) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_475.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None });
     }
-    if (__v_480 != __v_12) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None });
+    if (__v_484 != __v_12) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_484.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None });
     }
-    if (__v_489 != __v_13) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_489.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None });
+    if (__v_493 != __v_13) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_493.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None });
     }
-    if (__v_498 != __v_14) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_498.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None });
+    if (__v_502 != __v_14) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_502.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None });
     }
-    if (__v_507 != __v_15) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_507.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None });
+    if (__v_511 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_511.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None });
     }
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_355.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_508: G = __loaded[0];
-    let __v_509: G = __loaded[1];
-    let __v_510: G = __loaded[2];
-    let __v_511: G = G::from_u64(1);
-    let __v_512: G = G::from_u64(1);
-    if (__v_508 != __v_511) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_508.as_canonical_u64(), rhs: __v_511.as_canonical_u64(), msg: None });
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_359.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_512: G = __loaded[0];
+    let __v_513: G = __loaded[1];
+    let __v_514: G = __loaded[2];
+    let __v_515: G = G::from_u64(1);
+    let __v_516: G = G::from_u64(1);
+    if (__v_512 != __v_515) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_515.as_canonical_u64(), msg: None });
     }
-    if (__v_509 != __v_512) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_509.as_canonical_u64(), rhs: __v_512.as_canonical_u64(), msg: None });
+    if (__v_513 != __v_516) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_513.as_canonical_u64(), rhs: __v_516.as_canonical_u64(), msg: None });
     }
-    if (__v_510 != __v_512) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_510.as_canonical_u64(), rhs: __v_512.as_canonical_u64(), msg: None });
+    if (__v_514 != __v_516) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_516.as_canonical_u64(), msg: None });
     }
-    let __v_513: G = G::from_u64(1);
-    if (__v_356 != __v_513) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_356.as_canonical_u64(), rhs: __v_513.as_canonical_u64(), msg: None });
+    let __v_517: G = G::from_u64(1);
+    if (__v_360 != __v_517) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_360.as_canonical_u64(), rhs: __v_517.as_canonical_u64(), msg: None });
     }
-    let __v_514: G = G::from_u64(1);
-    if (__v_357 != __v_514) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_357.as_canonical_u64(), rhs: __v_514.as_canonical_u64(), msg: None });
+    let __v_518: G = G::from_u64(1);
+    if (__v_361 != __v_518) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_518.as_canonical_u64(), msg: None });
     }
-    let __ret: [G; OUT_191] = [];
-    if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_204] = [];
+    if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_192: usize = 2;
-const IN_192: usize = 2;
-const OUT_192: usize = 1;
-fn aiur_fn_192(
-  inp: [G; IN_192],
+const INPUT_SIZE_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_192], ExecError> {
+) -> Result<[G; OUT_205], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
     let __v_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];
@@ -19445,8 +20500,8 @@ fn aiur_fn_192(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_192] = [__v_4];
-        if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_205] = [__v_4];
+        if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19456,15 +20511,15 @@ fn aiur_fn_192(
   })
 }
 
-const INPUT_SIZE_193: usize = 1;
-const IN_193: usize = 1;
-const OUT_193: usize = 1;
-fn aiur_fn_193(
-  inp: [G; IN_193],
+const INPUT_SIZE_206: usize = 1;
+const IN_206: usize = 1;
+const OUT_206: usize = 1;
+fn aiur_fn_206(
+  inp: [G; IN_206],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_193], ExecError> {
+) -> Result<[G; OUT_206], 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 };
@@ -19473,87 +20528,18 @@ fn aiur_fn_193(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_193] = [__v_4];
-        if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_193] = [__v_4];
-        if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_194: usize = 2;
-const IN_194: usize = 2;
-const OUT_194: usize = 2;
-fn aiur_fn_194(
-  inp: [G; IN_194],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_194], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    match __v_3.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_194] = [__v_4, __v_5];
-        if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_195: usize = 1;
-const IN_195: usize = 1;
-const OUT_195: usize = 1;
-fn aiur_fn_195(
-  inp: [G; IN_195],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_195], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_195] = [__v_6];
-        if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_206] = [__v_4];
+        if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
-        let __v_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_195] = [__v_8];
-        if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+        let __v_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_206] = [__v_6];
+        if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19563,15 +20549,15 @@ fn aiur_fn_195(
   })
 }
 
-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_207: usize = 1;
+const IN_207: usize = 1;
+const OUT_207: usize = 1;
+fn aiur_fn_207(
+  inp: [G; IN_207],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_196], ExecError> {
+) -> Result<[G; OUT_207], 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 };
@@ -19582,80 +20568,35 @@ fn aiur_fn_196(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_196] = [__v_5];
-        if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = (__v_5 + __v_6);
-        let __ret: [G; OUT_196] = [__v_7];
-        if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_197: usize = 2;
-const IN_197: usize = 2;
-const OUT_197: usize = 1;
-fn aiur_fn_197(
-  inp: [G; IN_197],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_197], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_197] = [__v_1];
-        if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_207] = [__v_5];
+        if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_197] = [__v_14];
-        if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_5 + __v_6);
+        let __ret: [G; OUT_207] = [__v_7];
+        if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_198: usize = 2;
-const IN_198: usize = 2;
-const OUT_198: usize = 1;
-fn aiur_fn_198(
-  inp: [G; IN_198],
+const INPUT_SIZE_208: usize = 2;
+const IN_208: usize = 2;
+const OUT_208: usize = 1;
+fn aiur_fn_208(
+  inp: [G; IN_208],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_198], 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];
@@ -19665,17 +20606,17 @@ fn aiur_fn_198(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_198] = [__v_1];
-        if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_208] = [__v_1];
+        if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
         let __v_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_198] = [__v_7];
-        if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_208] = [__v_7];
+        if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19685,57 +20626,56 @@ fn aiur_fn_198(
   })
 }
 
-const INPUT_SIZE_199: usize = 2;
-const IN_199: usize = 2;
-const OUT_199: usize = 1;
-fn aiur_fn_199(
-  inp: [G; IN_199],
+const INPUT_SIZE_209: usize = 1;
+const IN_209: usize = 1;
+const OUT_209: usize = 1;
+fn aiur_fn_209(
+  inp: [G; IN_209],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_199], 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];
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
     match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_209] = [__v_7];
+        if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
       0u64 => {
-        let __ret: [G; OUT_199] = [__v_0];
-        if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+        let __v_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_209] = [__v_9];
+        if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = (__v_1 - __v_2);
-        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __ret: [G; OUT_199] = [__v_7];
-            if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_200: usize = 1;
-const IN_200: usize = 1;
-const OUT_200: usize = 1;
-fn aiur_fn_200(
-  inp: [G; IN_200],
+const INPUT_SIZE_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_200], ExecError> {
+) -> Result<[G; OUT_210], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
@@ -19749,17 +20689,17 @@ fn aiur_fn_200(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_200] = [__v_8];
-        if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_210] = [__v_8];
+        if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } };
+        let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_8 + __v_9);
-        let __ret: [G; OUT_200] = [__v_10];
-        if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_210] = [__v_10];
+        if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19769,15 +20709,15 @@ fn aiur_fn_200(
   })
 }
 
-const INPUT_SIZE_201: usize = 1;
-const IN_201: usize = 1;
-const OUT_201: usize = 1;
-fn aiur_fn_201(
-  inp: [G; IN_201],
+const INPUT_SIZE_211: usize = 1;
+const IN_211: usize = 1;
+const OUT_211: usize = 1;
+fn aiur_fn_211(
+  inp: [G; IN_211],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_201], ExecError> {
+) -> Result<[G; OUT_211], 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 };
@@ -19794,17 +20734,17 @@ fn aiur_fn_201(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_201] = [__v_11];
-        if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_211] = [__v_11];
+        if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(1);
         let __v_13: G = (__v_11 + __v_12);
-        let __ret: [G; OUT_201] = [__v_13];
-        if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_211] = [__v_13];
+        if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19814,19 +20754,19 @@ fn aiur_fn_201(
   })
 }
 
-const INPUT_SIZE_202: usize = 2;
-const IN_202: usize = 2;
-const OUT_202: usize = 4;
-fn aiur_fn_202(
-  inp: [G; IN_202],
+const INPUT_SIZE_212: usize = 2;
+const IN_212: usize = 2;
+const OUT_212: usize = 4;
+fn aiur_fn_212(
+  inp: [G; IN_212],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_202], 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 __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
@@ -19837,8 +20777,8 @@ fn aiur_fn_202(
     let __v_8: G = __loaded[5];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_202] = [__v_4, __v_5, __v_6, __v_7];
-        if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_212] = [__v_4, __v_5, __v_6, __v_7];
+        if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19848,40 +20788,149 @@ fn aiur_fn_202(
   })
 }
 
-const INPUT_SIZE_203: usize = 1;
-const IN_203: usize = 1;
-const OUT_203: usize = 1;
-fn aiur_fn_203(
-  inp: [G; IN_203],
+const INPUT_SIZE_213: usize = 1;
+const IN_213: usize = 1;
+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_203], ExecError> {
+) -> Result<[G; OUT_213], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __ret: [G; OUT_213] = [__v_4];
+        if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_213] = [__v_4];
+        if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_214: usize = 2;
+const IN_214: usize = 2;
+const OUT_214: usize = 2;
+fn aiur_fn_214(
+  inp: [G; IN_214],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_214], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_214] = [__v_4, __v_5];
+        if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_215: usize = 2;
+const IN_215: usize = 2;
+const OUT_215: usize = 1;
+fn aiur_fn_215(
+  inp: [G; IN_215],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_215], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_215] = [__v_1];
+        if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_12: G = G::from_u64(0);
+        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_215] = [__v_14];
+        if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_216: usize = 1;
+const IN_216: usize = 1;
+const OUT_216: usize = 1;
+fn aiur_fn_216(
+  inp: [G; IN_216],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_216], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
     let __v_4: G = __loaded[3];
     let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_203] = [__v_9];
-        if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_216] = [__v_6];
+        if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = (__v_9 + __v_10);
-        let __ret: [G; OUT_203] = [__v_11];
-        if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
+        let __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_216] = [__v_8];
+        if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19891,35 +20940,82 @@ fn aiur_fn_203(
   })
 }
 
-const INPUT_SIZE_204: usize = 1;
-const IN_204: usize = 1;
-const OUT_204: usize = 1;
-fn aiur_fn_204(
-  inp: [G; IN_204],
+const INPUT_SIZE_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_204], ExecError> {
+) -> Result<[G; OUT_217], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_217] = [__v_0];
+        if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = (__v_1 - __v_2);
+        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_217] = [__v_7];
+            if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_218: usize = 1;
+const IN_218: usize = 1;
+const OUT_218: usize = 1;
+fn aiur_fn_218(
+  inp: [G; IN_218],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_218], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    let __v_7: G = __loaded[6];
+    let __v_8: G = __loaded[7];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_204] = [__v_4];
-        if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_9: G = G::from_u64(0);
+        let __ret: [G; OUT_218] = [__v_9];
+        if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-        let __v_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_204] = [__v_6];
-        if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = (__v_9 + __v_10);
+        let __ret: [G; OUT_218] = [__v_11];
+        if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
@@ -19929,28 +21025,28 @@ fn aiur_fn_204(
   })
 }
 
-const INPUT_SIZE_205: usize = 2;
-const IN_205: usize = 2;
-const OUT_205: usize = 1;
-fn aiur_fn_205(
-  inp: [G; IN_205],
+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_205], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_205] = [__v_0];
-        if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_219] = [__v_0];
+        if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = (__v_1 - __v_2);
-        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         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];
@@ -19959,8 +21055,8 @@ fn aiur_fn_205(
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_205] = [__v_8];
-            if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_219] = [__v_8];
+            if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -19972,28 +21068,28 @@ 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_220: usize = 2;
+const IN_220: usize = 2;
+const OUT_220: usize = 1;
+fn aiur_fn_220(
+  inp: [G; IN_220],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_206], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_206] = [__v_0];
-        if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_220] = [__v_0];
+        if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
         return Ok(__ret);
       },
       _ => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = (__v_1 - __v_2);
-        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } };
         let __v_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];
@@ -20004,8 +21100,8 @@ fn aiur_fn_206(
         let __v_10: G = __loaded[5];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_206] = [__v_10];
-            if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_220] = [__v_10];
+            if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
             return Ok(__ret);
           },
           _ => {
@@ -21059,6 +22155,76 @@ pub(crate) fn execute_generated(
       let __out = aiur_fn_206(__inp, record, io_buffer, false)?;
       return Ok(__out.to_vec());
     },
+    207u64 => {
+      let __inp: [G; IN_207] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_207(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    208u64 => {
+      let __inp: [G; IN_208] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_208(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    209u64 => {
+      let __inp: [G; IN_209] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_209(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    210u64 => {
+      let __inp: [G; IN_210] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_210(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    211u64 => {
+      let __inp: [G; IN_211] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_211(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    212u64 => {
+      let __inp: [G; IN_212] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_212(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    213u64 => {
+      let __inp: [G; IN_213] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_213(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    214u64 => {
+      let __inp: [G; IN_214] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_214(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    215u64 => {
+      let __inp: [G; IN_215] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_215(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    216u64 => {
+      let __inp: [G; IN_216] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_216(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    217u64 => {
+      let __inp: [G; IN_217] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_217(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    218u64 => {
+      let __inp: [G; IN_218] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_218(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    219u64 => {
+      let __inp: [G; IN_219] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_219(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    220u64 => {
+      let __inp: [G; IN_220] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_220(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
     _ => {
       return Err(ExecError::InvalidFunIdx(fun_idx));
     },
diff --git a/crates/kernel/src/def_eq.rs b/crates/kernel/src/def_eq.rs
index 4c06046eb..7d8f84d5f 100644
--- a/crates/kernel/src/def_eq.rs
+++ b/crates/kernel/src/def_eq.rs
@@ -87,8 +87,8 @@ impl<M: KernelMode> TypeChecker<'_, M> {
       eprintln!(
         "[deq] {} {} ~ {}",
         self.fuel_used(),
-        &a.hash_key(),
-        &b.hash_key(),
+        a.hash_key(),
+        b.hash_key(),
       );
     }
     if a.ptr_eq(b) {
diff --git a/crates/kernel/src/inductive.rs b/crates/kernel/src/inductive.rs
index 86ae079de..b5f0bc436 100644
--- a/crates/kernel/src/inductive.rs
+++ b/crates/kernel/src/inductive.rs
@@ -3868,13 +3868,7 @@ impl<M: KernelMode> TypeChecker<'_, M> {
     };
     let univ_offset = match rec_ids.first() {
       Some(rid) => match self.try_get_const(rid)? {
-        Some(KConst::Recr { lvls, .. }) => {
-          if lvls > ind_lvls {
-            1u64
-          } else {
-            0u64
-          }
-        },
+        Some(KConst::Recr { lvls, .. }) if lvls > ind_lvls => 1u64,
         _ => 0,
       },
       None => 0,
diff --git a/crates/kernel/src/ingress.rs b/crates/kernel/src/ingress.rs
index 85ddbf8b6..1f8b7eba2 100644
--- a/crates/kernel/src/ingress.rs
+++ b/crates/kernel/src/ingress.rs
@@ -3875,17 +3875,7 @@ fn drop_ixon_env(ixon_env: IxonEnv, quiet: bool) {
   // set. Dropping them inline alongside the bookkeeping below is
   // negligible compared to the DashMap dropdance.
   // `..` covers the env's private fields.
-  let IxonEnv {
-    consts,
-    named,
-    blobs,
-    names,
-    comms,
-    anon_hints: _,
-    main: _,
-    assumptions: _,
-    ..
-  } = ixon_env;
+  let IxonEnv { consts, named, blobs, names, comms, .. } = ixon_env;
   let consts_len = consts.len();
   let named_len = named.len();
   let names_len = names.len();
diff --git a/crates/kernel/src/perf.rs b/crates/kernel/src/perf.rs
index 8f1bcf888..033a77615 100644
--- a/crates/kernel/src/perf.rs
+++ b/crates/kernel/src/perf.rs
@@ -291,7 +291,7 @@ impl PerfCounters {
     let peak = self.peak_rec_fuel_used.load(Ordering::Relaxed);
     let total = self.total_rec_fuel_used.load(Ordering::Relaxed);
     let n = self.constants_checked.load(Ordering::Relaxed);
-    let avg = if n > 0 { total / n } else { 0 };
+    let avg = total.checked_div(n).unwrap_or(0);
     writeln!(out, "[ix-perf] rec_fuel:")?;
     writeln!(
       out,
diff --git a/crates/kernel/src/tc.rs b/crates/kernel/src/tc.rs
index 3ba5fa617..5fd8348cd 100644
--- a/crates/kernel/src/tc.rs
+++ b/crates/kernel/src/tc.rs
@@ -917,13 +917,12 @@ impl<'a, M: KernelMode> TypeChecker<'a, M> {
     // Sharding profiler: flush the just-finished constant's heartbeats and
     // delta-unfold edges. `delta_targets` is always drained (even when
     // `cur_const` is unset) so producers never leak into the next constant.
-    if self.env.profile_sink.is_some() {
+    if let Some(sink) = &mut self.env.profile_sink {
       let producers = std::mem::take(&mut self.delta_targets);
       // Always drain the op counters (even when `cur_const` is unset) so they
       // never leak into the next constant, mirroring `delta_targets`.
       let ops = crate::profile::take_op_counts();
       if let Some(addr) = self.cur_const.take() {
-        let sink = self.env.profile_sink.as_mut().unwrap();
         sink.record(addr, used, producers, ops);
       }
     }
diff --git a/crates/kernel/src/whnf.rs b/crates/kernel/src/whnf.rs
index 8c628713f..38557a953 100644
--- a/crates/kernel/src/whnf.rs
+++ b/crates/kernel/src/whnf.rs
@@ -373,7 +373,7 @@ impl<M: KernelMode> TypeChecker<'_, M> {
     // Step journal (see `IX_STEP_TRACE` in def_eq.rs); placed after the
     // quick exit to mirror the Lean kernel's `[whnf+]` site.
     if *IX_STEP_TRACE {
-      eprintln!("[whnf+] {} {}", self.fuel_used(), &e.hash_key());
+      eprintln!("[whnf+] {} {}", self.fuel_used(), e.hash_key());
     }
 
     // Context-aware cache: closed exprs use ptr only; open exprs include
@@ -2010,11 +2010,11 @@ impl<M: KernelMode> TypeChecker<'_, M> {
       Err(_) => return Ok(KSynthOutcome::Inconclusive),
     };
     if *IX_KSYNTH_LOG {
-      eprintln!("[ksynth-attempt] {}", &ctor_app.hash_key());
+      eprintln!("[ksynth-attempt] {}", ctor_app.hash_key());
     }
     if !self.is_def_eq(&major_ty_w, &ctor_ty)? {
       if *IX_KSYNTH_LOG {
-        eprintln!("[ksynth-reject] {}", &ctor_app.hash_key());
+        eprintln!("[ksynth-reject] {}", ctor_app.hash_key());
       }
       // Cheap projection reduction can report a false negative that a later
       // full comparison resolves.  Only a normal/full DefEq rejection can be
diff --git a/flake.lock b/flake.lock
index a5b07edb9..a18b189f8 100644
--- a/flake.lock
+++ b/flake.lock
@@ -33,17 +33,17 @@
         ]
       },
       "locked": {
-        "lastModified": 1787415051,
-        "narHash": "sha256-14ziKcXwmJ/ZihFpp3Cg6FLVPM8kCUVzR6t0iyae1hE=",
+        "lastModified": 1787430037,
+        "narHash": "sha256-0dLeEO55z4nHvSv8xb9BMoCZTbIc9IqVuId7z8oa4kA=",
         "owner": "argumentcomputer",
         "repo": "Blake3.lean",
-        "rev": "1b0fbd2bd78b2b873e14264037af8c8b1536b9e9",
+        "rev": "e6e908bfd3af607ab44fb462fa2276a2c81addba",
         "type": "github"
       },
       "original": {
         "owner": "argumentcomputer",
         "repo": "Blake3.lean",
-        "rev": "1b0fbd2bd78b2b873e14264037af8c8b1536b9e9",
+        "rev": "e6e908bfd3af607ab44fb462fa2276a2c81addba",
         "type": "github"
       }
     },
diff --git a/flake.nix b/flake.nix
index 546e2f6df..9254cf0bc 100644
--- a/flake.nix
+++ b/flake.nix
@@ -31,7 +31,7 @@
 
     # Blake3 Rust bindings for Lean
     blake3-lean = {
-      url = "github:argumentcomputer/Blake3.lean/1b0fbd2bd78b2b873e14264037af8c8b1536b9e9";
+      url = "github:argumentcomputer/Blake3.lean/e6e908bfd3af607ab44fb462fa2276a2c81addba";
       # System packages, follows lean4-nix so we stay in sync
       inputs.lean4-nix.follows = "lean4-nix";
     };
@@ -79,7 +79,7 @@
           # Pins the Rust toolchain
           rustToolchain = fenix.packages.${system}.fromToolchainFile {
             file = ./rust-toolchain.toml;
-            sha256 = "sha256-sqSWJDUxc+zaz1nBWMAJKTAGBuGWP25GCftIOlCEAtA=";
+            sha256 = "sha256-P30Tm3O7vQAE725YtDCDHGjNrSsfZO4us11UwJGZSJo=";
           };
 
           # Rust package
diff --git a/lake-manifest.json b/lake-manifest.json
index 9a93b385c..bcd9d4714 100644
--- a/lake-manifest.json
+++ b/lake-manifest.json
@@ -35,10 +35,10 @@
    "type": "git",
    "subDir": null,
    "scope": "",
-   "rev": "1b0fbd2bd78b2b873e14264037af8c8b1536b9e9",
+   "rev": "e6e908bfd3af607ab44fb462fa2276a2c81addba",
    "name": "Blake3",
    "manifestFile": "lake-manifest.json",
-   "inputRev": "1b0fbd2bd78b2b873e14264037af8c8b1536b9e9",
+   "inputRev": "e6e908bfd3af607ab44fb462fa2276a2c81addba",
    "inherited": false,
    "configFile": "lakefile.lean"},
   {"url": "https://github.com/argumentcomputer/LSpec",
diff --git a/lakefile.lean b/lakefile.lean
index ec304c5bf..cfbcb5fe1 100644
--- a/lakefile.lean
+++ b/lakefile.lean
@@ -13,7 +13,7 @@ BLAKE3 backend to Lean's native evaluator, and that dynlib gates every
 `IxTcVerify` module, so this pin must stay at or after the revision that
 introduced the target. -/
 require Blake3 from git
-  "https://github.com/argumentcomputer/Blake3.lean" @ "1b0fbd2bd78b2b873e14264037af8c8b1536b9e9"
+  "https://github.com/argumentcomputer/Blake3.lean" @ "e6e908bfd3af607ab44fb462fa2276a2c81addba"
 
 require Cli from git
   "https://github.com/leanprover/lean4-cli" @ "v4.33.0"
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index a5b578d83..23de05434 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
 # The default profile includes rustc, rust-std, cargo, rust-docs, rustfmt and clippy.
 profile = "default"
-channel = "1.92"
+channel = "1.98"